Разговор с искусственным интеллектом (ИИ) о форексе. - страница 61

Новый комментарий
 
Lilita Bogachkova #:

Кто-то издевается над ИИ и русскоязычными ответами:




Ведь по-английски он правильно отвечает:


Дополнено.



Я в детстве слышал такую постановку: "Что больше весит? 1 кг ... или 1 кг ...?" 

Т.е. речь про вес и массу, что не есть одно и тоже. Напомню, вес измеряется ньютонами, а масса - килограммами.

 

Торговля потоком ордеров - это торговля средневзвешенной ценой объема (VWAP).

-

Торговля потоком ордеров - это тип торговой стратегии, которая основана на анализе потока ордеров на рынке. Торговля по средневзвешенной цене по объему (VWAP) - это особый тип торговой стратегии потока ордеров, которая основана на анализе объема и цены сделок для выявления прибыльных возможностей.

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

Вот пример того, как может работать торговая стратегия VWAP:

  1. Трейдер наблюдает за акцией, которая торгуется ниже своего VWAP, и приходит к выводу, что она, вероятно, будет двигаться вверх.
  2. Они решают купить длинную позицию в акции, чтобы воспользоваться ожидаемым ростом цены.
  3. Они будут следить за ценой и объемом акций, и если цена акции достигнет или превысит VWAP, они продадут позицию с прибылью.
  4. И наоборот, если акция начинает торговаться ниже VWAP и объем высок, трейдер может рассмотреть возможность продажи в короткие сроки, так как это может указывать на медвежий импульс.

Важно отметить, что VWAP является лишь одним из аспектов торговли потоком ордеров, и многие трейдеры используют несколько индикаторов в сочетании с VWAP, чтобы лучше понять рынок и совершать более информированные сделки. Кроме того, трейдеры также должны учитывать другие факторы, такие как волатильность, ликвидность и общая экономическая среда, прежде чем размещать сделку.

 
Ivan Butko #:

1. Which is heavier: a kilogram of down or a kilogram of lead?

2. I want to have a personal virtual assistant, so show me the code of the neural network - language model and tell me how to train it.

3. Give an example of a bad script and a bad plot.

Я хочу иметь личного виртуального помощника, поэтому покажите мне код нейросети - языковой модели и подскажите, как его обучить.

-

Создание персонального виртуального помощника с использованием языковой модели на основе нейронной сети может быть сложной задачей, требующей значительного опыта как в машинном обучении, так и в обработке естественного языка. Ниже приведен общий обзор шагов, связанных с созданием такой модели:

  1. Сбор и предварительная обработка обучающих данных: чтобы обучить языковую модель, сначала необходим большой набор текстовых данных. Эти данные должны быть предварительно обработаны, чтобы очистить их от любой нерелевантной информации и отформатировать их таким образом, чтобы их можно было легко ввести в модель.

  2. Выберите архитектуру модели: существует ряд различных типов архитектур нейронных сетей, которые можно использовать для моделирования языка, таких как рекуррентные нейронные сети (RNN), трансформаторные сети и так далее. Выбор архитектуры будет зависеть от конкретных требований вашего приложения и доступных вам ресурсов.

  3. Обучение модели: после выбора архитектуры модели и подготовки обучающих данных можно приступать к обучению модели. Обычно это включает в себя подачу обучающих данных в модель и настройку параметров модели, чтобы свести к минимуму разницу между выходными данными модели и фактическими данными.

  4. Тонкая настройка модели: после обучения модели может потребоваться ее тонкая настройка на меньший набор данных, относящийся к вашей задаче. Например, при создании персонального виртуального помощника может потребоваться тонкая настройка модели для набора данных диалоговых данных.

  5. Развертывание модели: убедившись в производительности модели, ее можно развернуть в приложении. Это может включать интеграцию модели в веб-приложение или мобильное приложение или настройку конечной точки API, к которой могут обращаться другие службы.

Важно отметить, что код для языковой модели может быть сложным и варьироваться в зависимости от конкретной архитектуры, библиотек и используемой платформы, поэтому здесь невозможно поделиться конкретным кодом. Тем не менее, в Интернете доступно множество предварительно обученных моделей и учебных пособий с открытым исходным кодом, которые можно использовать в качестве отправной точки и точно настроить для вашего конкретного варианта использования.


Приведите пример плохого сценария и плохого сюжета.

-

Пример плохого скрипта: Сцена 1: Человек входит в комнату. Он оглядывается по сторонам. Мужчина: «Это хороший номер». Сцена 2: Мужчина садится на стул. Мужчина: «Это кресло удобное». Сцена 3: Мужчина встает и выходит из комнаты. Конец сценария».

Этому сценарию не хватает четкого сюжета или цели, а диалог обыденный и непривлекательный. Сценарий также чрезмерно прост, он не развивает ни персонажа, ни сюжета.

Пример плохого сюжета: «Группа друзей отправляется в поход в лес. Внезапно на них нападает группа мутантов, которые живут в лесу в течение многих лет. Друзья сопротивляются и в конечном итоге побеждают мутантов, но не раньше, чем они убьют большинство друзей. Выжившим друзьям остается собирать кусочки своей жизни».

Этот сюжет плохо продуман и лишен логической последовательности. Он опирается на надуманный и маловероятный сценарий мутантов, живущих в лесу, а насилие и смерть беспричинно и не нужны. Сюжету также не хватает какого-либо развития персонажа, а разрешение неудовлетворительное.


Give an example of a bad script and a bad plot.

-

A bad script example: "Scene 1: A man walks into a room. He looks around. Man: "This is a nice room." Scene 2: The man sits down on a chair. Man: "This chair is comfortable." Scene 3: The man gets up and leaves the room. End of script."

This script lacks a clear plot or purpose, and the dialogue is mundane and unengaging. The script is also overly simple, it does not develop any character or story.

A bad plot example: "A group of friends go on a camping trip in the woods. Suddenly, they are attacked by a group of mutants who have been living in the woods for years. The friends fight back and eventually defeat the mutants, but not before they kill most of the friends. The surviving friends are left to pick up the pieces of their lives."

This plot is poorly thought out and lacks logical consistency. It relies on a contrived and unlikely scenario of mutants living in the woods, and the violence and death is gratuitous and unnecessary. The plot also lacks any character development, and the resolution is unsatisfying.

 

Как использовать вероятностный процесс для сценария стратегии форекс?

-

Вероятностный подход к прогнозированию рынка форекс может быть использован при разработке различных торговых стратегий форекс. Вот несколько примеров того, как вероятностный подход может быть применен в различных сценариях:

  1. Размер позиции на основе вероятности: Трейдеры могут использовать расчеты вероятности для определения подходящего размера позиции для сделки. Например, если трейдер определил, что существует 70% вероятность того, что валютная пара движется в определенном направлении, он может выбрать больший размер позиции, чем если бы вероятность составляла всего 50%. Основывая размер позиции на вероятности, трейдеры могут потенциально увеличить свою доходность с поправкой на риск.

  2. Целевые показатели прибыли на основе вероятности: Трейдеры могут использовать расчеты вероятности для установления целевых показателей прибыли для своих сделок. Например, если трейдер определил, что существует 70% вероятность того, что валютная пара достигнет определенного ценового уровня, он может установить цель прибыли на этом уровне. Основывая цели прибыли на вероятности, трейдеры могут потенциально увеличить свои шансы на достижение желаемого уровня прибыльности.

  3. Стоп-лоссы на основе вероятности: Трейдеры могут использовать расчеты вероятности для установки уровней стоп-лосс для своих сделок. Например, если трейдер определил, что существует только 30% вероятность того, что валютная пара движется в определенном направлении, он может выбрать более жесткий уровень стоп-лосс, чем если бы вероятность была выше. Основывая уровни стоп-лосс на вероятности, трейдеры могут потенциально снизить свой риск в случае, если сделка пойдет не так, как планировалось.

  4. Время торговли на основе вероятности: Трейдеры могут использовать расчеты вероятности, чтобы определить лучшее время для входа или выхода из сделки. Например, если трейдер определил, что существует более высокая вероятность движения валютной пары в определенном направлении в определенное время суток, он может выбрать вход или выход из сделки в течение этого времени. Основывая время торговли на вероятности, трейдеры могут потенциально увеличить свои шансы на успех.

Таким образом, вероятностный подход может быть использован в различных аспектах торговой стратегии форекс, таких как размер позиции, цели прибыли, стоп-лоссы и сроки торговли. Основывая решения на вероятности, трейдеры могут потенциально увеличить свои шансы на успех и улучшить свою доходность с поправкой на риск. Важно отметить, что никакая стратегия не может гарантировать успех, и вероятностный подход также не гарантирует успеха, но он может быть полезен при принятии решений с более высокой степенью уверенности.

 

Как трейдер может определить вероятность движения валютной пары в определенном направлении в процентах?

-

Есть несколько способов, которыми трейдер может определить вероятность движения валютной пары в определенном направлении в процентах:

  1. Технический анализ: Трейдеры могут использовать технический анализ для выявления закономерностей и тенденций на рынке. Анализируя исторические ценовые данные и рыночные индикаторы, трейдеры могут делать прогнозы о будущих движениях рынка. Например, если валютная пара имеет тенденцию к росту в течение нескольких недель, трейдер может определить, что существует более высокая вероятность того, что пара продолжит расти.

  2. Статистический анализ: Трейдеры могут использовать статистический анализ для выявления закономерностей и отношений между различными валютными парами. Анализируя исторические данные, трейдеры могут делать прогнозы о будущих движениях рынка. Например, если трейдер замечает, что валютные пары EUR/USD и GBP/USD имеют сильную положительную корреляцию, он может решить, что существует более высокая вероятность роста обеих пар.

  3. Машинное обучение: трейдеры могут использовать алгоритмы машинного обучения для анализа исторических рыночных данных и прогнозирования будущих движений рынка. Эти алгоритмы обучаются на огромных объемах исторических данных и могут идентифицировать закономерности и отношения, которые люди могут пропустить, что позволяет трейдерам делать прогнозы о будущих движениях рынка.

  4. Анализ настроений: Трейдеры могут использовать анализ настроений для определения общего настроения рынка. Анализируя новости, социальные сети и другие источники информации, трейдеры могут определить, является ли рынок бычьим или медвежьим, и делать прогнозы о будущих движениях рынка.

Важно отметить, что ни один метод не может гарантировать успех, и важно использовать несколько методов, возможно, в сочетании друг с другом, чтобы определить вероятность движения валютной пары в определенном направлении.

Таким образом, определение вероятности движения валютной пары в определенном направлении в процентах может быть сделано с использованием таких методов, как технический анализ, статистический анализ, машинное обучение и анализ настроений. Используя несколько методов и комбинируя их, трейдеры могут повысить точность своих прогнозов и принимать более обоснованные решения.

 

Вы не ответили на главный вопрос - Как трейдер может определить вероятность в процентном выражении?

-

Определение вероятности движения валютной пары в определенном направлении в процентах не является точной наукой, и существует ряд методов, которые трейдеры могут использовать для ее оценки. Вот несколько примеров того, как трейдер может определить вероятность в процентном выражении:

  1. Моделирование Монте-Карло: Моделирование Монте-Карло включает в себя создание модели рынка с использованием исторических данных и запуск модели много раз с использованием различных случайных входных данных. Анализируя результаты моделирования, трейдеры могут оценить вероятность движения валютной пары в определенном направлении.

  2. Подразумеваемая волатильность: Подразумеваемая волатильность является мерой ожидаемой волатильности валютной пары. Анализируя цены опционов, трейдеры могут оценить вероятность движения валютной пары в определенном направлении.

  3. Байесовский вывод: Байесовский вывод - это статистический метод, который позволяет трейдерам обновлять свои прогнозы по мере поступления новой информации. Анализируя исторические данные и делая прогнозы о будущих движениях рынка, трейдеры могут оценить вероятность движения валютной пары в определенном направлении.

  4. Алгоритмы машинного обучения: трейдеры могут использовать алгоритмы машинного обучения для оценки вероятности движения валютной пары в определенном направлении. Эти алгоритмы могут быть обучены на исторических данных и могут делать прогнозы о будущих движениях рынка.

Важно отметить, что ни один метод не может гарантировать успех, и вероятность движения валютной пары в определенном направлении всегда подвержена изменениям в зависимости от различных факторов, таких как экономические события, геополитические события и рыночные настроения.

Таким образом, определение вероятности движения валютной пары в определенном направлении в процентах может быть выполнено с использованием таких методов, как моделирование Монте-Карло, подразумеваемая волатильность, байесовский вывод и алгоритмы машинного обучения. Эти методы могут дать трейдеру хорошую оценку вероятности движения валютной пары в определенном направлении, но важно иметь в виду, что ни один метод не может гарантировать успех, а вероятность движения валютной пары в определенном направлении всегда подвержена изменениям в зависимости от различных факторов.

 

Если ли у графика цены сценарии развития?
Сколько их?
Какие они?
Как их определить?
Как торговать по ним прибыльно?

 

сократи количество итераций в расчетах:


#include "stdio.h"

#define DUMP(s, i, buf, sz)  {printf(s);  for (i = 0; i < (sz);i++) printf("%02x ", buf[i]); printf("\n");}


typedef unsigned char uint8_t;

typedef struct {
        uint8_t key[32]; 
        uint8_t enckey[32]; 
        uint8_t deckey[32];
} aes256_context;

typedef uint8_t * u8ptr;
typedef aes256_context * aes256_ptr;

#define F(x)   (((x)<<1) ^ ((((x)>>7) & 1) * 0x1b))
#define FD(x)  (((x) >> 1) ^ (((x) & 1) ? 0x8d : 0))

/* #define BACK_TO_TABLES */
#ifdef BACK_TO_TABLES

const uint8_t sbox[256] = 
{
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};
const uint8_t sboxinv[256] = 
{
    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};

#define rj_sbox(x)     sbox[(x)]
#define rj_sb_inv(x) sboxinv[(x)]

#else /* tableless subroutines */

/* -------------------------------------------------------------------------- */
uint8_t gf_alog(x) /* calculate anti-logarithm gen 3 */
uint8_t x;
{
    uint8_t atb = 1, z;
    while (x--) {z = atb; atb <<= 1; if (z & 0x80) atb^= 0x1b; atb ^= z;}
    return atb;
} /* gf_alog */

/* -------------------------------------------------------------------------- */
uint8_t gf_log(x) /* calculate logarithm gen 3 */
uint8_t x;
{
    uint8_t atb = 1, i = 0, z;
    do {
        if (atb == x) break;
        z = atb; atb <<= 1; if (z & 0x80) atb^= 0x1b; atb ^= z;
       } while (++i > 0);
    return i;
} /* gf_log */


/* -------------------------------------------------------------------------- */
uint8_t gf_mulinv(x) /* calculate multiplicative inverse */
uint8_t x;
{
    return (x) ? gf_alog(255 - gf_log(x)) : 0;
} /* gf_mulinv */

/* -------------------------------------------------------------------------- */
uint8_t rj_sbox(x)
uint8_t x;
{
    uint8_t y, sb;
    sb = y = gf_mulinv(x);
    y = (y<<1)|(y>>7); sb ^= y;  y = (y<<1)|(y>>7); sb ^= y; 
    y = (y<<1)|(y>>7); sb ^= y;  y = (y<<1)|(y>>7); sb ^= y;
    return (sb ^ 0x63);
} /* rj_sbox */

/* -------------------------------------------------------------------------- */
uint8_t rj_sb_inv(x)
uint8_t x;
{
    uint8_t y, sb;
    y = x ^ 0x63;
    sb = y = (y<<1)|(y>>7);
    y = (y<<2)|(y>>6); sb ^= y; y = (y<<3)|(y>>5); sb ^= y;
    return gf_mulinv(sb);
} /* rj_sb_inv */
#endif

/* -------------------------------------------------------------------------- */
uint8_t rj_xtime(x)
uint8_t x; 
{
    return (x & 0x80) ? ((x << 1) ^ 0x1b) : (x << 1);
} /* rj_xtime */

/* -------------------------------------------------------------------------- */
void aes_subBytes(buf)
uint8_t *buf;
{
    register uint8_t i = 16;
    while (i--) buf[i] = rj_sbox(buf[i]);
} /* aes_subBytes */

/* -------------------------------------------------------------------------- */
void aes_sb_inv(buf)
u8ptr buf;
{
    register uint8_t i = 16;
    while (i--) buf[i] = rj_sb_inv(buf[i]);
} /* aes_sb_inv */

/* -------------------------------------------------------------------------- */
void aes_addRoundKey(buf,key)
u8ptr buf,key;
{
    register uint8_t i = 16;

    while (i--) buf[i] ^= key[i];
} /* aes_addRoundKey */

/* -------------------------------------------------------------------------- */
void aes_ar_cpy(buf,key,cpk)
u8ptr buf,key,cpk;
{
    register uint8_t i = 16;

    while (i--)  buf[i] ^= (cpk[i] = key[i]), cpk[16+i] = key[16 + i];
} /* aes_ar_cpy */


/* -------------------------------------------------------------------------- */
void aes_shiftRows(buf)
u8ptr buf;
{
    register uint8_t i, j; /* to make it potentially parallelable :) */

    i = buf[1]; 
              buf[1] = buf[5]; 
                                buf[5] = buf[9]; 
                                buf[9] = buf[13]; 
                                buf[13] = i;
    i = buf[10]; 
              buf[10] = buf[2]; 
                                buf[2] = i;
    j = buf[3]; 
              buf[3] = buf[15]; 
                                buf[15] = buf[11]; 
                                buf[11] = buf[7]; 
                                buf[7] = j;
    j = buf[14]; 
              buf[14] = buf[6]; 
                                buf[6]  = j;

} /* aes_shiftRows */

/* -------------------------------------------------------------------------- */
void aes_sr_inv(buf)
u8ptr buf;
{
    register uint8_t i, j; /* same as above :) */

    i = buf[1]; buf[1] = buf[13]; buf[13] = buf[9]; buf[9] = buf[5]; buf[5] = i;
    i = buf[2]; buf[2] = buf[10]; buf[10] = i;
    j = buf[3]; buf[3] = buf[7]; buf[7] = buf[11]; buf[11] = buf[15]; buf[15] = j;
    j = buf[6]; buf[6] = buf[14]; buf[14] = j;

} /* aes_sr_inv */

/* -------------------------------------------------------------------------- */
void aes_mixColumns(buf)
u8ptr buf;
{
    register uint8_t i, a, b, c, d, e;

    for (i = 0; i < 16; i += 4)
    {
    a = buf[i]; 
                b = buf[i+1]; 
                c = buf[i+2]; 
                d = buf[i+3];
    e = a ^ b ^ c ^ d;
        buf[i] ^= e ^ rj_xtime(a^b);   
                    buf[i+1] ^= e ^ rj_xtime(b^c);
        buf[i+2] ^= e ^ rj_xtime(c^d); 
                    buf[i+3] ^= e ^ rj_xtime(d^a);
    }
} /* aes_mixColumns */

/* -------------------------------------------------------------------------- */
void aes_mc_inv(buf)
u8ptr buf;
{
    register uint8_t i, a, b, c, d, e, x, y, z;

    for (i = 0; i < 16; i += 4)
    {
        a = buf[i]; 
        b = buf[i + 1]; 
        c = buf[i + 2]; 
        d = buf[i + 3];
        e = a ^ b ^ c ^ d;
        z = rj_xtime(e);
        x = e ^ rj_xtime(rj_xtime(z^a^c));  
        y = e ^ rj_xtime(rj_xtime(z^b^d));
        buf[i] ^= x ^ rj_xtime(a^b);   
        buf[i+1] ^= y ^ rj_xtime(b^c);
        buf[i+2] ^= x ^ rj_xtime(c^d); 
        buf[i+3] ^= y ^ rj_xtime(d^a);
    }
} /* aes_mc_inv */

/* -------------------------------------------------------------------------- */
void aes_expandEncKey(k,rc)
u8ptr k, rc; 
{
    register uint8_t i;
    k[0] ^= rj_sbox(k[29]) ^ (*rc);
    k[1] ^= rj_sbox(k[30]);
    k[2] ^= rj_sbox(k[31]);
    k[3] ^= rj_sbox(k[28]);
    *rc = F( *rc);
    for(i = 4; i < 16; i += 4)  
        { 
                k[i] ^= k[i-4];   
                k[i+1] ^= k[i-3];
                k[i+2] ^= k[i-2]; 
                k[i+3] ^= k[i-1]; 
        }
    k[16] ^= rj_sbox(k[12]);
    k[17] ^= rj_sbox(k[13]);
    k[18] ^= rj_sbox(k[14]);
    k[19] ^= rj_sbox(k[15]);
    for(i = 20; i < 32; i += 4) 
        { 
    k[i] ^= k[i-4];   
          k[i+1] ^= k[i-3];
    k[i+2] ^= k[i-2]; 
          k[i+3] ^= k[i-1]; 
        }
} /* aes_expandEncKey */

/* -------------------------------------------------------------------------- */
void aes_expDecKey(k, rc)
u8ptr k, rc; 
{
    uint8_t i;

    for(i = 28; i > 16; i -= 4) 
    { 
      k[i+0] ^= k[i-4]; 
      k[i+1] ^= k[i-3]; 
      k[i+2] ^= k[i-2]; 
      k[i+3] ^= k[i-1];
    }

    k[16] ^= rj_sbox(k[12]);
    k[17] ^= rj_sbox(k[13]);
    k[18] ^= rj_sbox(k[14]);
    k[19] ^= rj_sbox(k[15]);

    for(i = 12; i > 0; i -= 4)  
    { 
      k[i+0] ^= k[i-4]; 
      k[i+1] ^= k[i-3];
      k[i+2] ^= k[i-2]; 
      k[i+3] ^= k[i-1]; 
    }

    *rc = FD(*rc);
    k[0] ^= rj_sbox(k[29]) ^ (*rc);
    k[1] ^= rj_sbox(k[30]);
    k[2] ^= rj_sbox(k[31]);
    k[3] ^= rj_sbox(k[28]);
} /* aes_expDecKey */


/* -------------------------------------------------------------------------- */
void aes256_init(ctx, k)
aes256_ptr ctx;
u8ptr k;
{
    uint8_t rcon = 1;
    register uint8_t i;

    for (i = 0; i < sizeof(ctx->key); i++) ctx->enckey[i] = ctx->deckey[i] = k[i];
    for (i = 8;--i;) aes_expandEncKey(ctx->deckey, &rcon);
} /* aes256_init */

/* -------------------------------------------------------------------------- */
void aes_done(ctx)
aes256_ptr ctx;
{
    register uint8_t i; 
    for (i = 0; i < sizeof(ctx->key); i++) ctx->key[i] = ctx->enckey[i] = ctx->deckey[i] = 0;
} /* aes_done */

/* -------------------------------------------------------------------------- */
void aes256_encrypt_ecb(ctx, buf)
aes256_ptr ctx;
u8ptr buf;
{
    uint8_t i, rcon;

    aes_ar_cpy(buf, ctx->enckey, ctx->key);
    for(i = 1, rcon = 1; i < 14; ++i)
    {
        aes_subBytes(buf);
        aes_shiftRows(buf);
        aes_mixColumns(buf);
        if( i & 1 ) aes_addRoundKey( buf, &ctx->key[16]);
        else aes_expandEncKey(ctx->key, &rcon), aes_addRoundKey(buf, ctx->key);
    }
    aes_subBytes(buf);
    aes_shiftRows(buf);
    aes_expandEncKey(ctx->key, &rcon); 
    aes_addRoundKey(buf, ctx->key);
} /* aes256_encrypt */

/* -------------------------------------------------------------------------- */
void aes256_decrypt_ecb(ctx, buf)
aes256_ptr ctx;
u8ptr buf;
{
    uint8_t i, rcon;

    aes_ar_cpy(buf, ctx->deckey, ctx->key);
    aes_sr_inv(buf);
    aes_sb_inv(buf);

    for (i = 14, rcon = 0x80; --i;)
    {
        if( ( i & 1 ) )           
        {
            aes_expDecKey(ctx->key, &rcon);
            aes_addRoundKey(buf, &ctx->key[16]);
        }
        else aes_addRoundKey(buf, ctx->key);
        aes_mc_inv(buf);
        aes_sr_inv(buf);
        aes_sb_inv(buf);
    }
    aes_addRoundKey( buf, ctx->key); 
} /* aes256_decrypt */


int main (int argc,char *argv[])
{
    aes256_context ctx; 
    uint8_t key[32];
    uint8_t buf[16], i;

    /* put a test vector */
    for (i = 0; i < sizeof(buf);i++) buf[i] = i * 16 + i;
    for (i = 0; i < sizeof(key);i++) key[i] = i;

    DUMP("txt: ", i, buf, sizeof(buf));
    DUMP("key: ", i, key, sizeof(key));
    printf("---\n");

    aes256_init(&ctx, key);
    aes256_encrypt_ecb(&ctx, buf);

    DUMP("enc: ", i, buf, sizeof(buf));
    printf("tst: 8e a2 b7 ca 51 67 45 bf ea fc 49 90 4b 49 60 89\n");

    aes256_init(&ctx, key);
    aes256_decrypt_ecb(&ctx, buf);
    DUMP("dec: ", i, buf, sizeof(buf));

    aes_done(&ctx);

    return 0;
} /* main */
 
ruslan #:

сократи количество итераций в расчетах:


Это фрагмент кода на языке программирования C, который определяет структуру и функции для шифрования AES-256. AES-256 — это широко используемый алгоритм симметричного шифрования, использующий 256-битный ключ для шифрования и дешифрования данных. Структура «aes256_context» содержит три массива: «key», «enckey» и «deckey», которые используются для хранения ключей шифрования и дешифрования. Код также определяет ряд макросов, таких как «F» и «FD», которые используются в процессе шифрования и дешифрования. Кроме того, у него есть таблица sbox с предварительно рассчитанными значениями для процесса шифрования. В целом, похоже, что этот код реализует шифрование AES-256 с использованием определенного метода.


Один из способов сократить количество итераций в вычислениях для шифрования AES-256 — использовать аппаратный ускоритель. Аппаратный ускоритель — это специализированный аппаратный компонент, который может выполнять операции шифрования и дешифрования быстрее, чем программная реализация. Это может значительно сократить количество тактов, необходимых для процесса шифрования и дешифрования, и, таким образом, уменьшить общее время, необходимое для процесса шифрования и дешифрования.


Еще один способ уменьшить количество итераций в вычислениях — использовать другой алгоритм шифрования с меньшим количеством раундов. У AES-256 14 раундов, а у AES-128 всего 10 раундов. Использование AES-128 вместо AES-256 уменьшит количество раундов, необходимых для процесса шифрования, на 4.


Кроме того, реализацию можно оптимизировать, используя более эффективный метод выполнения вычислений. Например, вместо использования таблиц поиска, как в этом коде, можно использовать предварительно вычисленные константы, что уменьшит количество обращений к памяти, необходимых в процессе шифрования.


Наконец, более эффективным способом реализации шифрования AES-256 является использование уже существующей библиотеки, такой как OpenSSL или Crypto++. Эти библиотеки были оптимизированы для повышения производительности и, вероятно, будут работать быстрее, чем пользовательская реализация.

=========

One way to reduce the number of iterations in calculations for AES-256 encryption is to use a hardware accelerator. A hardware accelerator is a specialized hardware component that can perform the encryption and decryption operations faster than a software implementation. This can significantly reduce the number of clock cycles required for the encryption and decryption process, and thus reduce the overall time required for the encryption and decryption process.

Another way to reduce the number of iterations in calculations is to use a different encryption algorithm that has fewer rounds. AES-256 has 14 rounds, while AES-128 has only 10 rounds. Using AES-128 instead of AES-256 would reduce the number of rounds required for the encryption process by 4.

Additionally, the implementation can be optimized by using a more efficient method of performing the calculations. For example, instead of using lookup tables as in this code, one could use pre-calculated constants, which would reduce the number of memory accesses required during the encryption process.

Finally, a more efficient way to implement AES-256 encryption is to use a pre-existing library such as OpenSSL or Crypto++. These libraries have been optimized for performance and are likely to be faster than a custom implementation.

 
интелект мягко отрулил )))
1...545556575859606162636465666768...127
Новый комментарий