Как да изберете произволна стойност от масив в PHP. Php random: Как да получите произволна стойност от масив с помощта на произволни числа

изберете елемент (11)

Имам масив, наречен $ran = array(1,2,3,4);

Трябва да получа произволна стойност от този масив и да я съхраня в променлива, как мога да направя това?

Отговори

Базирам отговора си на функцията на @OlafurWaage. Опитах се да го използвам, но се натъкнах на проблеми с помощта, когато се опитах да променя върнатия обект. Актуализирах функцията му за предаване и връщане по препратка. Нова функция:

Функция &random_value(&$array, $default=null) ( $k = mt_rand(0, count($array) - 1); if (isset($array[$k])) ( return $array[$k]; ) else ( return $default; ) )

За повече информация вижте моя въпрос в Предаване/връщане на препратки към обекти + Промяната на обект не работи

$стойност = $масив;

Можете да използвате функцията array_rand, за да изберете произволен ключ от вашия масив, както е показано по-долу.

$масив = масив("едно", "две", "три", "четири", "пет", "шест"); ехо $масив;

или можете да използвате функциите rand и count, за да изберете произволен индекс.

$масив = масив("едно", "две", "три", "четири", "пет", "шест"); ехо $масив;

$random = $ran;

Това също е полезно като функция, ако имате нужда от стойност

Функция random_value($array, $default=null) ( $k = mt_rand(0, count($array) - 1); return isset($array[$k])? $array[$k]: $default; )

Вашият избор има ли някакви последици за сигурността? Ако е така, използвайте random_int() и array_keys(). (random_bytes() е само PHP 7, но има polyfill за PHP 5).

Функция random_index(array $source) ( $max = count($source) - 1; $r = random_int(0, $max); $k = array_keys($source); return $k[$r]; )

Приложение:

$array = [ "apple" => 1234, "boy" => 2345, "cat" => 3456, "dog" => 4567, "echo" => 5678, "fortune" => 6789 ]; $i = случаен_индекс($масив); var_dump([$i, $масив[$i]]);

Функция array_random($array, $amount = 1) ( $keys = array_rand($array, $amount); if ($amount == 1) ( return $array[$keys]; ) $results = ; foreach ($keys като $key) ( $results = $array[$key]; ) върне $results; )

Приложение:

$items = ["foo", "bar", "baz", "lorem"=>"ipsum"]; array_random($items); // "лента" array_random($items, 2); // ["foo", "ipsum"]

Няколко бележки:

• $сума трябва да е по-малка или равна на count($array).
• array_rand() не разбърква ключовете (от PHP 5.2.10, вижте), така че избраните от вас елементи винаги ще бъдат в оригиналния ред. Използвайте shuffle(), ако е необходимо.

редактиране:Функцията Laravel нарасна значително оттогава, вижте Laravel 5.4"s Arr::random(). Ето нещо по-сложно, произтичащо от зряла функция на Laravel:

Функция array_random($array, $number = null) ( $requested = ($number === null) ? 1: $number; $count = count($array); if ($requested > $count) ( хвърляне на нов \ RangeException("Вие поискахте ($requested) елементи, но има само ($count) налични елементи."); ) if ($number === null) ( return $array; ) if ((int) $number == = 0) ( return ; ) $keys = (масив) array_rand($array, $number); $results = ; foreach ($keys като $key) ( $results = $array[$key]; ) return $results; )

Няколко акцента:

• Хвърлете изключение, ако няма достатъчно налични елементи
• array_random($array, 1) връща масив от един елемент (#19826)
• Поддържана стойност "0" за брой елементи (Това е чисто и просто.

Вече няколко пъти ме питаха как съм случаен изход на кавичкина моя уебсайт в блока " Интелигентни цитатиСлед това успях да разбера, че проблемът тук е в неразбирането на хората, как да получите произволен елемент от масив в PHP. Задачата е проста, но въпреки това, тъй като възникват въпроси, те трябва да получат отговор.

Веднага ще ви дам кода. Да кажем, че има масив с набор от кавички. И трябва да изберете един произволен един от тях и да изведете:

$кавички = масив(); // Инициализиране на празен масив
$quotes = "Бъдете внимателни към мислите си, те са началото на действията."; // Първи цитат
$quotes = "Не оцеляват най-умните или най-силните, а най-възприемчивите към промяна."; // Втори цитат
$quotes = "Животът е планина: изкачваш се бавно, слизаш бързо."; // Трети цитат
$quotes = "Хората не искат да бъдат богати, хората искат да бъдат по-богати от другите."; // Четвърти цитат
$число = mt_rand(0, брой($кавички) - 1); // Вземете произволно число от 0 до (дължина на масива минус 1) включително
echo $quotes[$number]; // Изведете цитат
?>

Ключовият момент е получаване на произволно число. Всичко, което трябва да направите, е да поставите правилните граници. Ако трябва да изберете произволен елемент по цялата дължина на масива, тогава това е от 0 преди ( дължина на масива минус 1). И тогава просто издърпайте елемент от масива с получения произволен индекс.

Що се отнася до задачата с цитати, по-добре е да ги съхранявате в база данни. По принцип, ако сайтът е много прост, тогава може да се направи в текстов файл. Но ако в база данни, тогава е по-добре да се използва РАНД()И ОГРАНИЧЕНИЕ V SQL заявка, така че веднага да получите единична и произволна оферта от базата данни.

Случайните стойности са навсякъде в PHP. Във всички рамки, в много библиотеки. Вероятно сами сте написали много код, който използва произволни стойности за генериране на жетони и соли и като вход към функции. Също така, случайните стойности играят важна роля при решаването на различни проблеми:

1. За произволен избор на опции от набор или набор от известни опции.
2. За генериране на инициализиращи вектори за криптиране.
3. За генериране на непредвидими жетони или еднократни стойности по време на оторизация.
4. За генериране на уникални идентификатори, като идентификатори на сесии.

Във всички тези случаи има характерна уязвимост. Ако нападател познае или предвиди изхода на вашия генератор на произволни числа (RNG) или генератор на псевдо-случайни числа (PRNG), той ще може да изчисли токените, солите, nonces и векторите за криптографска инициализация, създадени от този генератор. Ето защо е много важно да се генерират висококачествени произволни стойности, т.е. такива, които са изключително трудни за прогнозиране. Никога не правете предсказуеми токените за повторно задаване на парола, CSRF токените, API ключовете, nonces или токените за оторизация!

Има две други потенциални уязвимости, свързани с произволни стойности в PHP:

1. Разкриване на информация.
2. Недостатъчна ентропия.

В този контекст „разкриване на информация“ се отнася до изтичане на вътрешното състояние на генератор на псевдослучайни числа – неговата начална стойност. Течове като тези могат да направят прогнозирането на бъдещи PRNG резултати много по-лесно.

„Липсата на ентропия“ описва ситуация, при която променливостта на първоначалното вътрешно състояние (семена) на PRNG или неговия изход е толкова малка, че целият диапазон от възможни стойности е относително лесен за груба сила. Не е много добра новина за PHP програмистите.

Ще разгледаме подробно и двете уязвимости с примерни сценарии за атака. Но първо, нека разберем какво всъщност е случайна стойност, когато става дума за програмиране на PHP.

Какво правят случайните стойности?

Объркването относно предназначението на случайните променливи се усложнява от общо неразбиране. Без съмнение сте чували за разликата между криптографски силни произволни стойности и неясни „уникални“ стойности „за други цели“. Основното впечатление е, че произволните стойности, използвани в криптографията, изискват висококачествена случайност (или по-точно висока ентропия), докато стойностите за други приложения могат да преминат с по-малко ентропия. Намирам това впечатление за погрешно и контрапродуктивно. Истинската разлика между непредсказуемите случайни стойности и тези, необходими за тривиални задачи, е, че предвидимостта на последните не води до вредни последици. Това напълно изключва криптографията от разглеждане. С други думи, ако използвате произволна стойност в нетривиален проблем, трябва автоматично да изберете много по-силни RNG.

Силата на произволните стойности се определя от ентропията, изразходвана за генерирането им. Ентропията е мярка за несигурност, изразена в "битове". Например, ако взема двоичен бит, неговата стойност може да бъде 0 или 1. Ако нападателят не знае точната стойност, тогава имаме ентропия от 2 бита (т.е. хвърляне на монета). Ако атакуващият знае, че стойността винаги е 1, тогава имаме ентропия от 0 бита, тъй като предвидимостта е антонимът на несигурността. Освен това броят на битовете може да варира от 0 до 2. Например, ако 99% от времето един двоичен бит е 1, тогава ентропията може да е малко по-голяма от 0. Така че колкото повече недефинирани двоични битове избираме, толкова по-добре.

В PHP това може да се види по-ясно. Функцията mt_rand() генерира произволни стойности, те винаги са числа. Не показва букви, специални знаци или други значения. Това означава, че за всеки байт нападателят има много по-малко предположения, т.е. ниска ентропия. Ако заменим mt_rand() с четене на байтове от източника на Linux /dev/random, получаваме наистина произволни байтове: те се генерират въз основа на шум, генериран от драйвери на системни устройства и други източници. Очевидно тази опция е много по-добра, защото осигурява значително повече битове ентропия.

Нежелаността на mt_rand() се посочва и от факта, че той не е генератор на наистина произволни, а псевдослучайни числа или, както се нарича още, детерминистичен генератор на произволни двоични последователности (Deterministic Random Bit Generator, DRBG ). Той прилага алгоритъм, наречен Mersenne Twister, който генерира числа, разпределени по такъв начин, че резултатът да е близък до резултата от истински генератор на случайни числа. mt_rand() използва само една случайна стойност - семената; въз основа на нея фиксиран алгоритъм генерира псевдослучайни стойности.

Разгледайте този пример, можете да го тествате сами:

Това е прост цикъл, изпълняван след като функцията PHP Mersenne vortex получи първоначална, предварително зададена стойност. Той беше получен от изхода на функцията, дадена като пример в документацията за mt_srand() и използвайки текущите секунди и микросекунди. Ако изпълните горния код, той ще покаже 25 псевдослучайни числа. Изглеждат произволни, няма съвпадения, всичко е наред. Нека стартираме кода отново. Забелязахте ли нещо? А именно: показват се ЕДНАКВИ числа. Нека го пуснем за трети, четвърти, пети път. В по-старите версии на PHP резултатът може да е различен, но това не е проблемът, тъй като е общ за всички съвременни версии на PHP.

Ако атакуващият получи началната стойност на такъв PRNG, тогава той ще може да предвиди целия изход на mt_rand(). Така че защитата на първоначалната стойност е от изключително значение. Ако го загубите, вече нямате право да генерирате произволни стойности...

Можете да генерирате първоначалната стойност по един от двата начина:

• ръчно, като използвате функцията mt_srand(),
• ще игнорирате mt_srand() и ще оставите PHP да го генерира автоматично.

Вторият вариант е за предпочитане, но дори и днес наследените приложения често наследяват използването на mt_srand(), дори след пренасяне към по-модерни версии на PHP.

Това увеличава риска нападателят да възстанови първоначалната стойност (Seed Recovery Attack), което ще му даде достатъчно информация, за да предвиди бъдещи стойности. В резултат на това всяко приложение след такова изтичане става уязвимо за атака за разкриване на информация. Това е истинска уязвимост, въпреки привидно пасивната си природа. Изтичането на информация за локалната система може да помогне на нападателя при последващи атаки, които ще нарушат принципа на защита в дълбочина.

Случайни стойности в PHP

PHP използва три PRNG и ако атакуващият получи достъп до семената, използвани в техните алгоритми, той ще може да предвиди резултатите от тяхната работа:

1. Линеен конгруентен генератор (LCG), lcg_value().
2. Мерсенов вихър, mt_rand() .
3. Локално поддържана C функция rand().

Тези генератори се използват и вътрешно, за функции като array_rand() и uniqid(). Това означава, че атакуващият може да предвиди изхода на тези и други функции, които използват вътрешните PRNG на PHP, ако получат всички необходими семена. Това също означава, че не можете да подобрите защитата си, като обърквате нападателя с множество обаждания към генераторите. Това важи особено за приложения с отворен код. Нападателят е в състояние да предвиди ВСИЧКИ изходи за всяка начална стойност, която му е известна.

За да подобри качеството на генерираните произволни стойности за нетривиални задачи, PHP се нуждае от външни източници на ентропия, предоставени от операционната система. В Linux обикновено се използва /dev/urandom, можете да го прочетете директно или да получите индиректен достъп до него чрез функциите openssl_pseudo_random_bytes() или mcrypt_create_iv(). И двата могат да използват криптографски защитен генератор на псевдослучайни числа (CSPRNG) в Windows, но в PHP в потребителското пространство все още няма директен метод за получаване на данни от този генератор без разширенията, предоставени от тези функции. С други думи, уверете се, че вашата сървърна версия на PHP има активирано разширение OpenSSL или Mcrypt.

/dev/urandom е PRNG, но често получава нови семена от източника с висока ентропия /dev/random. Това го прави безинтересна цел за нападател. Опитваме се да избягваме четене директно от /dev/random, защото това е блокиращ ресурс. Ако ентропията му свърши, тогава всички четения ще бъдат блокирани, докато отново не получи достатъчно ентропия от системната среда. Въпреки че за най-важните задачи трябва да използвате /dev/random.

Всичко това ни води до правилото:

Ще намерите основно изпълнение на това правило в референтната библиотека на SecurityMultiTool. Както обикновено, вътрешните елементи на PHP предпочитат да усложняват живота на програмистите, вместо директно да включват сигурни решения в ядрото на PHP.

Стига теория, сега да видим как можете да атакувате приложение, въоръжени с горното.

Атака срещу генератори на случайни числа в PHP

Поради редица причини PHP използва PRNG за решаване на нетривиални проблеми.

Функцията openssl_pseudo_random_bytes() беше достъпна само в PHP 5.3. В Windows причинява проблеми с блокирането, докато не излезе версия 5.3.4. Също така в PHP 5.3 функцията mcrypt_create_iv() на Windows започна да поддържа източника MCRYPT_DEV_URANDOM. Преди това Windows поддържаше само MCRYPT_RAND - по същество същият системен PRNG, използван вътрешно от функцията rand(). Както можете да видите, преди PHP 5.3 имаше много пропуски, така че много наследени приложения, написани в предишни версии, може да не са преминали към по-силни PRNG.

Изборът на Openssl и Mcrypt разширения е по ваша преценка. Тъй като не може да се разчита, че са налични дори на сървъри, работещи с PHP 5.3, приложенията често използват PRNG, вградени в PHP, като резервен вариант за генериране на нетривиални произволни стойности.

Но и в двата случая имаме нетривиални проблеми, които използват произволни стойности, генерирани от PRNG със семена с ниска ентропия. Това ни прави уязвими за атаки за извличане. Нека да разгледаме един прост пример.

Нека си представим, че намерихме онлайн приложение, което използва следния код за генериране на токени, които се използват в различни задачи в приложението:

Има по-сложни средства за генериране на токени, но това е добър вариант. Има само едно извикване на mt_rand(), хеширано с SHA512. На практика, ако програмист реши, че функциите за произволна стойност на PHP са „достатъчно произволни“, тогава той най-вероятно ще избере опростения подход, докато не се спомене думата „криптография“. Например некриптографските случаи включват токени за достъп, CSRF токени, еднократни стойности на API и токени за повторно задаване на парола. Преди да продължа, ще опиша подробно пълната степен на уязвимостта на това приложение, така че да разберете по-добре какво прави приложенията уязвими на първо място.

Характеристики на уязвимото приложение

Това не е изчерпателен списък. На практика списъкът с характеристики може да се различава!

1. Сървърът използва mod_php, който, когато се използва с KeepAlive, позволява множество заявки да бъдат обслужвани от един и същ PHP процес

Това е важно, тъй като генераторите на произволни числа в PHP се поставят само веднъж на процес. Ако можем да направим две или повече заявки към процеса, тогава той ще използва същата първоначална стойност. Същността на атаката е да се използва разширяването на един токен за извличане на началната стойност, която е необходима за прогнозиране на друг токен, генериран въз основа на СЪЩАТА начална стойност (т.е. в същия процес). Тъй като mod_php е идеален за използване на множество заявки за извличане на свързани произволни стойности, понякога може да е възможно да се извлекат множество стойности, свързани с mt_rand() само с една заявка. Това прави всички изисквания на mod_php излишни. Например, част от ентропията, използвана за генериране на семената за mt_rand(), може да изтече през идентификатори на сесии или изходни стойности в същата заявка.

2. Сървърът разкрива CSRF токени, токени за нулиране на парола или токени за потвърждение на акаунт, генерирани въз основа на токени mt_rand().

За да извлечем началната стойност, трябва директно да проверим числото, генерирано от генераторите в PHP. И дори няма значение как се използва. Можем да го извлечем от всяка налична стойност, било то резултат от mt_rand(), или хеширан CSRF, или токен за потвърждение на акаунт. Подходящи са дори индиректни източници, при които произволна стойност определя различно поведение на изхода, което разкрива точно тази стойност. Основното ограничение е, че трябва да е от същия процес, който генерира втория токен, който се опитваме да предвидим. И това е уязвимост на „разкриване на информация“. Както скоро ще видим, изтичането на PRNG изход може да бъде изключително опасно. Имайте предвид, че уязвимостта не е ограничена до едно приложение: можете да прочетете PRNG изхода в едно приложение на сървъра и да го използвате, за да определите изхода в друго приложение на същия сървър, стига и двете да използват един и същ PHP процес.

3. Известен слаб алгоритъм за генериране на токени

Можете да го изчислите:

• след като се задълбочихте в източниците на приложението с отворен код,
• подкупване на служител с достъп до личен изходен код,
• намиране на бивш служител, който таи злоба към бившия си работодател,
• или просто познайте какъв алгоритъм може да има.

Някои методи за генериране на токени са по-очевидни, други са по-популярни. Наистина слабо генериране означава да използвате един от генераторите на случайни числа на PHP (напр. mt_rand()), слаба ентропия (няма други източници на недефинирани данни) и/или слабо хеширане (напр. MD5 или никакво хеширане). Примерът за код, обсъден по-горе, има отличителните белези на слаб метод за генериране. Използвах също хеширане на SHA512, за да покажа, че маскирането винаги е незадоволително решение. SHA512 е слабо хеширане, тъй като е бърз за изчисляване, което означава, че нападателят може грубо да форсира входните данни на всеки CPU или GPU с невероятна скорост. И не забравяйте, че законът на Мур също все още е в сила, което означава, че скоростта на грубата сила ще се увеличава с всяко ново поколение CPU/GPU. Следователно паролите трябва да се хешират с помощта на инструменти, които отнемат фиксирано време за разбиване, независимо от производителността на процесора или закона на Мур.

Извършване на атака

Нашата атака е съвсем проста. Като част от свързването към PHP процес, ние ще проведем бърза сесия и ще изпратим две отделни HTTP заявки (заявка A и заявка B). Сесията ще бъде задържана от сървъра до получаване на втората заявка. Заявка A е насочена към получаване на някакъв наличен токен като CSRF, токен за нулиране на парола (изпратен до нападателя по пощата) или нещо подобно. Не забравяйте за други функции като вградено маркиране, използвано при заявки за произволни идентификатори и т.н. Ще измъчваме оригиналния токен, докато не ни даде първоначалната си стойност. Всичко това е част от атака за възстановяване на семето: когато семето има толкова малка ентропия, че може да бъде грубо форсирано или потърсено в предварително изчислена дъгова таблица.

Заявка B ще реши по-интересен проблем. Нека направим заявка за нулиране на паролата на локалния администратор. Това ще задейства генерирането на токен (използвайки произволно число, базирано на същото семе, което изтегляме с Заявка А, ако и двете заявки са изпратени успешно до един и същ PHP процес). Този токен ще се съхранява в базата данни в очакване на момента, в който администраторът използва връзката за нулиране на паролата, изпратена му по имейл. Ако можем да извлечем началната стойност за токена от заявка A, тогава знаейки как се генерира токенът от заявка B, можем да предвидим токена за нулиране на паролата. Това означава, че можем да последваме връзката за нулиране, преди администраторът да прочете писмото!

Ето последователността от събития:

1. Използвайки заявка A, получаваме токена и го проектираме обратно, за да изчислим първоначалната стойност.
2. Използвайки заявка B, получаваме токен, генериран въз основа на същата първоначална стойност. Този токен се съхранява в базата данни на приложението за бъдещо нулиране на парола.
3. Разбиваме хеша на SHA512, за да получим произволното число, генерирано от сървъра.
4. Използвайки получената произволна стойност, ние грубо форсираме първоначалната стойност, която е генерирана с негова помощ.
5. Ние използваме семената, за да изчислим поредица от произволни стойности, които вероятно могат да формират основата на токен за нулиране на парола.
6. Ние използваме този токен(а) за нулиране на администраторската парола.
7. Получаваме достъп до администраторския акаунт, забавляваме се и печелим. Е, поне се забавляваме.

Да започнем да хакваме...

Стъпка по стъпка хакване на приложения

Стъпка 1. Направете заявка A за извличане на токена

Предполагаме, че целевият токен и токенът за нулиране на парола зависят от изхода на mt_rand(). Следователно трябва да го изберете. В приложението в нашия въображаем сценарий всички токени се генерират по един и същи начин, така че можем просто да извлечем CSRF токена и да го запазим за по-късно.

Стъпка 2. Изпълнете заявка B, за да получите токена за нулиране на парола, генериран за администраторския акаунт

Тази заявка е просто изпращане на формуляр за нулиране на парола. Токенът ще бъде записан в базата данни и изпратен на потребителя по пощата. Трябва да изчислим правилно този токен. Ако спецификациите на сървъра са точни, тогава заявка B използва същия PHP процес като заявка A. Следователно извикванията към mt_rand() ще използват същата начална стойност и в двата случая. Можете дори да използвате Заявка A, за да заснемете CSRF токена на формуляра за нулиране, за да разрешите подаването с цел рационализиране на процедурата (избягване на междинното двупосочно пътуване).

Стъпка 3. Хакнете SHA512 хеша на токена, получен от заявка A

SHA512 вдъхва страхопочитание сред програмистите: той има най-големия брой в цялото семейство алгоритми SHA-2. Има обаче един проблем с метода за генериране на токени на нашата жертва - произволните стойности са ограничени само до числа (т.е. степента на несигурност или ентропията е незначителна). Ако проверите изхода на mt_getrandmax(), ще откриете, че най-голямото произволно число, което mt_rand() може да генерира, е 2,147 милиарда и известна промяна. Този ограничен брой функции прави SHA512 уязвим на груба сила.

Просто не ми вярвай на думата. Ако имате дискретна видеокарта от едно от най-новите поколения, тогава можете да отидете по следния начин. Тъй като търсим единичен хеш, реших да използвам чудесен инструмент за груба сила - hashcat-lite. Това е една от най-бързите версии на hashcat и е достъпна за всички основни операционни системи, включително Windows.

Използвайте този код, за да генерирате токен:

Този код възпроизвежда токена от заявка A (съдържа произволното число, от което се нуждаем, и е скрито в хеша на SHA512) и го изпълнява през hashcat: