Обсуждение:RSA (криптосистема)

Что это значит ?

Я думаю, что необходимо больше информации о . Что это значит? Возьмите 2 простых числа, уменьшите их на 1, умножьте их друг на друга, но затем ? Сохраните результат в пустом множестве под номером 'n' ? Как пустое множество может что-то содержать ? -- Garo 21:52, 17 августа 2005 (UTC) [ ответить ] ϕ ( n ) = ( p − 1 ) ( q − 1 ) {\displaystyle \phi (n)=(p-1)(q-1)}

Это phi , а не пустое множество. В этом случае это просто новая функция, которую мы определили над областью всех целых чисел n , которые являются произведением двух больших простых чисел. Это, по сути, удобная запись для (p-1)(q-1) . Aerion //talk 23:20, 17 августа 2005 (UTC) [ ответить ]
Небольшая поправка: phi(n) — это функция Эйлера , которая определена по всем целым числам. Это количество целых чисел, меньших n, которые взаимно просты с n. Стоит ли упоминать об этом в статье, где впервые появляется phi(n)? Birge 06:26, 18 августа 2005 (UTC) [ ответить ]
Это совершенно сбивает с толку.
Почему λ(n) = (p − 1) * (q − 1) не работает? В статье говорится, что это должно быть НОК. Это правда?
И зачем вводить эти непонятные функции totient и lambda. Они ничего не делают для прояснения статьи.
Цель статей по математике, похоже, заключается в том, чтобы продемонстрировать ум математиков и быть непроницаемыми для всех остальных.
Эта статья должна быть понятна любому человеку с продвинутым уровнем математики в средней школе. Модульная арифметика, исчисление, но не тотиенты!

Tuntable ( обсуждение ) 00:46, 8 января 2024 (UTC) [ ответ ]

Я не уверен, что понимаю, о чем вы спрашиваете. В статье не говорится, что (p-1)*(q-1) «не работает». Там говорится как раз обратное: в оригинальной статье RSA функция тотиента Эйлера φ(n) = (p − 1)(q − 1) используется вместо λ(n) для вычисления частной экспоненты d. Поскольку φ(n) всегда делится на λ(n), алгоритм тоже работает. Функции тотиента трудно избежать при объяснении алгоритма, и я думаю, что объяснение было бы сложнее понять, если бы мы попытались это сделать, но вы, конечно, можете предложить формулировку, которая, по вашему мнению, будет яснее. CodeTalker ( talk ) 02:40, 8 января 2024 (UTC) [ reply ]

Дополнительное условие: e 2 ≠ 1  mod  ϕ ( n ) {\displaystyle e^{2}\neq 1{\text{ mod }}\phi (n)}

Привет,

Я читал эту статью об алгоритме RSA и что-то показалось мне проблемой в генерации ключей. Действительно, что произойдет, если мы выберем

  • e ∧ ϕ ( n ) = 1 {\displaystyle e\wedge \phi (n)=1}
  • e < ϕ ( n ) {\displaystyle e<\phi (n)}
  • но e 2 = 1  mod  ϕ ( n ) ? {\displaystyle e^{2}=1{\text{ mod }}\phi (n)?}

(Условия « и » — единственные два условия, упомянутые в статье.) Тогда это всегда действительный закрытый ключ. e ∧ ϕ ( n ) = 1 {\displaystyle e\wedge \phi (n)=1} e < ϕ ( n ) {\displaystyle e<\phi (n)} d = e {\displaystyle d=e}

На самом деле, мы ищем

  • d ∧ ϕ ( n ) = 1 {\displaystyle d\wedge \phi (n)=1}
  • e d = 1  mod  ϕ ( n ) {\displaystyle ed=1{\text{ mod }}\phi (n)}

Итак, если , то работает! Итак, когда известен открытый ключ, если тест верен, сообщение можно расшифровать. e 2 = 1  mod  ϕ ( n ) {\displaystyle e^{2}=1{\text{ mod }}\phi (n)} d = e {\displaystyle d=e} e 2 = 1  mod  ϕ ( n ) {\displaystyle e^{2}=1{\text{ mod }}\phi (n)}

Я считаю, что это общеизвестный факт, поскольку простой пример — открытый ключ (и его всегда рекомендуется избегать). Действительно выбрал ( e , n ) = ( 3 , 15 ) {\displaystyle (e,n)=(3,15)} e = 3 {\displaystyle e=3}

  • p = 3 , q = 5 {\displaystyle p=3,q=5}
  • n = 15 {\displaystyle n=15}
  • ϕ ( n ) = ( 3 − 1 ) ( 5 − 1 ) = 8 {\displaystyle \phi (n)=(3-1)(5-1)=8}
  • e = 3 {\displaystyle e=3} так e = 3  mod  8 {\displaystyle e=3{\text{ mod }}8}
  • еще e 2 = 9 = 1  mod  8 {\displaystyle e^{2}=9=1{\text{ mod }}8}

Таким образом, (3,15) не является допустимым открытым ключом, однако он удовлетворяет условиям, изложенным в статье Википедии.

Итак, каковы правильные условия? Во-первых, нам нужно спросить, что

  • e ∧ ϕ ( n ) = 1 {\displaystyle e\wedge \phi (n)=1}
  • e < ϕ ( n ) {\displaystyle e<\phi (n)}
  • но и e 2 ≠ 1  mod  ϕ ( n ) {\displaystyle e^{2}\neq 1{\text{ mod }}\phi (n)}

Однако мы видим, что если , то e = ϕ ( n ) − 1 {\displaystyle e=\phi (n)-1}

  • e = − 1  mod  ϕ ( n ) {\displaystyle e=-1{\text{ mod }}\phi (n)}
  • так e 2 = 1  mod  ϕ ( n ) {\displaystyle e^{2}=1{\text{ mod }}\phi (n)}

Итак, даже условие

  • e < ϕ ( n ) {\displaystyle e<\phi (n)}

не очень хорошо сформулировано, поскольку может включать в себя то, что запрещено . e = ϕ ( n ) − 1 {\displaystyle e=\phi (n)-1} e 2 ≠ 1  mod  ϕ ( n ) {\displaystyle e^{2}\neq 1{\text{ mod }}\phi (n)}

Поэтому я бы предложил следующие условия:

  • e ∧ ϕ ( n ) = 1 {\displaystyle e\wedge \phi (n)=1}
  • e < ϕ ( n ) − 1 {\displaystyle e<\phi (n)-1}
  • e 2 ≠ 1  mod  ϕ ( n ) . {\displaystyle e^{2}\neq 1{\text{ mod }}\phi (n).}

Имеет ли это смысл?

Клемент Джастин (обсуждение) 12:45, 24 июня 2016 (UTC) [ ответить ]

Это ограничение обычно включается без указания, поскольку NIST требует, чтобы 'e' не было больше 2^256, а totient обычно не так уж и мал, за исключением неудачно выбранных простых чисел. Поскольку totient не предоставляется с открытым ключом, один из способов проверить, что мой 'e' не нарушает эти условия, — это дважды зашифровать сообщение, а затем проверить, возвращается ли двойное шифрование к исходному значению. Что вы можете проверить, изменив пример страницы, чтобы использовать e=781 или e=779 или e=1+780*что угодно. В обоих случаях e и d (каждый mod lambda) идентичны, и двойное шифрование приводит к исходному сообщению.
Обратите внимание, что когда OpenSSL в настоящее время проверяет сертификат RSA, у них есть 2 вида ограничений для максимального 'e' в зависимости от длины бит, и они не проверяют, e2 mod totient = 1. Если длина бит 'n' составляет 3072 или меньше, он просто проверяет, что 'e' меньше 'n', а для большего 'n' он ограничивает 'e' длиной не более 2^64. Так что действительно OpenSSL в настоящее время не определяет, особенно в 2048-битных или 3072-битных ключах, является ли 'e' любым из многих значений, которые соответствуют вашим условиям. Silversplash ( talk ) 20:18, 25 января 2023 (UTC) [ ответить ]

Тотиент или LCM!?

В настоящее время статья гласит: «...вычислить тотиент лямбда(n) = lcm((p-1, q-1)». Но это не тотиент, тотиент равен (p-1)(q-1), что по крайней мере вдвое больше лямбды (потому что оба p-1, q-1 четные). Согласно более ранним комментариям, кажется, что раньше на странице говорилось «вычислить тотиент фи (или лямбда?) = (p-1)(q-1)». Теперь не очевидно, что два варианта дадут один и тот же результат (даже не ясно, что означает результат... может быть: модульная обратная величина?). Да? Если да, то это заслуживает замечания, по крайней мере. Если нет, то что следует использовать? — MFH : Talk 21:16, 22 мая 2018 (UTC) [ ответить ]

Почему в статье нет тотиента Эйлера?

Я видел множество известных сайтов и книг, использующих тотиент Эйлера, но он не используется в Википедии. Я создавал код RSA на основе вашей программы, только чтобы понять, что есть более быстрый и эффективный способ его кодирования, но он не был включен в статью. По крайней мере, тонкое упоминание было бы оценено. Cyclone26 ( обсуждение ) 23:06, 9 апреля 2019 (UTC) [ ответить ]

Тотиент Эйлера обсуждается в разделе Генерация ключей , включая указание на то, почему в этом разделе используется тотиент Кармайкла. Я сомневаюсь, что использование тотиента Эйлера более эффективно. Если предположить, что вес Хэмминга d является решающим фактором эффективности для операций с закрытым ключом, и что его вес Хэмминга в основном определяется его длиной, то тотиент Кармайкла более эффективен: небольшая цена, которую вы платите во время генерации ключа, в значительной степени окупается во время всех последующих операций с закрытым ключом. Я просто не совсем уверен, что мои предположения верны. Кстати, я также предполагаю, что вы не используете китайскую теорему об остатках для операций с закрытым ключом, как обсуждалось в разделе. Цифровые мозги ( обсуждение ) 10:14, 10 апреля 2019 (UTC) [ ответить ]
Ладно, на самом деле, если вы беспокоитесь об эффективности и, таким образом, используете китайскую теорему об остатках, возможно, вы могли бы также использовать Эйлера, поскольку CRT позаботится о дальнейшем сокращении. Это предполагает, что у вас есть контроль как над кодом генерации, так и над кодом операции закрытого ключа; если ваш ключ также может использоваться другим кодом операции закрытого ключа, все равно может быть целесообразно уменьшить длину d для этих реализаций (используя Кармайкла вместо Эйлера). Digital Brains ( обсуждение ) 10:19, 10 апреля 2019 (UTC) [ ответить ]

Безопасные простые числа в генерации ключей RSA

Я разместил ссылку на эту заметку здесь: https://en.wikipedia.org/wiki/RSA_(cryptosystem)#CryptoStrengthOfPQ

и здесь (старый отменённый кэш правок): https://en.wikipedia.org/w/index.php?title=RSA_(cryptosystem)&diff=983454044&oldid=983447902#CryptoStrengthOfPQ

Но мои правки были отменены: https://en.wikipedia.org/w/index.php?title=RSA_(cryptosystem)&oldid=983456104


Я все описал, затем поставил якорь и добавил эту ссылку на страницу определения безопасных простых чисел: https://en.wikipedia.org/w/index.php?title=Безопасные_числа_и_простые_числа_Софи_Жермен&diff=983441331&oldid=983436407


Главное, что там описано - исключить общие множители (общие делители) для чисел (p-1) и (q-1), и оставить только 2 в качестве общего множителя этого числа,

чтобы предотвратить простую факторизацию (n-1) и сделать ее такой сложной.


Когда p и q — безопасные простые числа, то p' = (p-1)/2, q' = (p-1)/2, где p' и q' — тоже простые числа, более того, это некоторые простые числа Софи-Жермен.

Итак, из-за этого числа (p-1) и (q-1) - имеют только один общий делитель (число 2).

Поскольку каждое из этих чисел можно разложить на множители только как (p-1) = 2*p'; (p-1) = 2*q',

и только 2 является общим множителем (результатом факторизации, делителем), в то время как p' и q' - разные простые числа, и это не общие делители.

Да, эти p' и q' являются простыми числами Софи-Жермен, но они не используются при генерации ключей,

и использовали безопасные простые числа - p и q, и это безопасные простые числа, а не простые числа Софи-Жермен.


Я все это там описал, и я не знаю, что еще нужно добавить,

объяснить решение этой проблемы с общими делителями (p-1) и (q-1),

проблема, которая была описана в предыдущей версии.


Но посмотрите на это:

p, q - простые числа;

n = p*q;

фи(n) = (p-1)*(q-1);

λ(n) = lcm((p−1),(q−1)); где λ — функция тотента Кармайкла.

НОК можно вычислить с помощью алгоритма Евклида, поскольку НОК(a,b) = |ab|/НОД(a,b), НОД — наибольший общий делитель.

λ(n) = |((p-1)*(q-1))|/НОД((p-1),(q-1)) = |фи(n)| / НОД((p-1),(q-1)) = фи(n)/НОД((p-1),(q-1)), так как фи(n) - положительное натуральное число;

Теперь давайте определим некоторые: g = gcd((p-1),(q-1));

λ(n) = фи(n)/g

g*λ(n) = фи(n);

g = фи(n)/λ(n);

Каждый x, который является взаимно простым с n = p*q, является делителем для ( (n-1) = (p*q-1) = ( (p−1)*(q−1) + (p−1)+(q−1) ) ), для (p-1), для (q-1) и для λ(n).

Таким образом, для вычисления d можно использовать формулу ( d*e === 1 ( mod λ(n) ) ), вместо ( d' * e === 1 ( mod phi(n) ) ).

Поскольку g = phi(n)/λ(n), ( d*e === 1 ( mod phi(n) ) ) -> ( d*e === 1 ( mod λ(n) ) ), поэтому d = d' mod λ(n) и (d !== d' mod phi(n));

После всего этого мы видим, что (d, d'+1*λ(n), d'+2*λ(n), ..., d'+(g-1)*λ(n)) - это и есть приватные ключи, криптоэквивалентные приватному ключу d.

Это означает, что g = gcd((p-1),(q-1)) — это число криптоэквивалентно закрытых ключей,

и когда это число растет, это снижает криптостойкость RSA-системы.

Лучший случай, когда g = gcd((p-1),(q-1)) = 2, и в этом случае p = 2*p'+1, q = 2*q'+1, где gcd(p',q')=1,

и где p' и q' – простые числа (простые числа Софи-Гермен), а где p и q - безопасные простые числа, поэтому, по определению.

В этом случае (p-1) и (q-1) имеют только один общий множитель (общий делитель) = 2.


Обсуждать.

Я перенес эту тему в правильное место, а именно в конец страницы.
Редакторы Википедии не имеют права решать, верно ли то, что вы написали. Но наша задача — проверить, подтверждаются ли ваши утверждения надежными источниками. Для этого вам необходимо предоставить такие надежные источники. Этого не было сделано. Напротив, ссылка 20 из Safe and Sophie Germain primes утверждает, что при современных алгоритмах факторизации выбор безопасных простых чисел не увеличивает безопасность. Поэтому нет необходимости настаивать на выборе простых чисел больше, чем это уже есть в статье. D.Lazard ( talk ) 14:01, 14 октября 2020 (UTC) [ ответить ]

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

https://studfile.net/preview/5367570/page:7/

Пункт 8.4, ключевые слова: "Очевидно, в наилучшем возможном случае..." - есть Безопасные Праймы.

После этого было описано использование сильных простых чисел, а также алгоритм для их генерации — алгоритм Гордона.

213.231.62.76 ( обсуждение ) 02:36, 15 октября 2020 (UTC) [ ответить ]

В справочнике описывается выбор «p» путем требования большого множителя для каждого из 3 связанных чисел (p-1) и (p+1) и для (p-1)/2. Метод FIPS для выбора простых чисел RSA был обновлен, чтобы рекомендовать метод, который достигает первых 2 из 3 качеств, но не 3-го.
В вашей ссылке говорится: «В общем случае p и q не должны отличаться от типичных представителей случайных простых чисел», но, допуская только безопасные простые числа в качестве простых чисел pq, это значительно замедлит генерацию ключей и сократит пул простых чисел, которые можно было бы выбрать. Кроме того, это означает, что p и q больше не являются «типичными». Среди больших простых чисел остаток от p-mod-12 может быть любым из 4 вариантов 1 5 7 11, но безопасные простые числа могут иметь только остаток 11, поэтому это требование отбросит 3/4 всех простых чисел. При наличии того же требования для p и q, вместо n-mod-144, являющегося любым из 10 возможных результатов, теперь будет только результат = 121.
Чтобы понять, насколько требование безопасного простого числа замедлит генерацию ключей, возьмем в качестве примера поиск RSA-4096 для 2048-битного числа «p». Среди b-битных чисел плотность простых чисел стремится к 1 на (b * log(2)) или 1 на 1420 чисел при 2048 битах. Но плотность простых чисел Софи Жермен среди b-1-битных чисел будет приблизительно 1 на ((b-1) * log(2))^2 / (двойная простая константа) или 1 на 1,52 миллиона чисел, что примерно в 1070 раз реже. Каждый раз, когда «метод Гордона» достигает кандидата, который является простым числом, будет крошечный шанс, что (p-1)/2 также является простым числом, и метод Гордона не является сокращением для этого. Silversplash ( обсуждение ) 00:08, 13 апреля 2023 (UTC) [ ответ ]
редактировать: следовало бы сказать (2*примерная константа-близнец) Silversplash ( обсуждение ) 17:32, 13 апреля 2023 (UTC) [ ответить ]

Bellcore против CRT

Я знаю, что статья не претендует на то, чтобы быть окончательным списком всех атак. Но поскольку в статье упоминается сокращение CRT для подписи/расшифровки и есть целый раздел атак против неотбитых сообщений RSA, вероятно, следует упомянуть атаку Bellcore, когда кто-то заставляет вас подписать одно и то же сообщение дважды, где одна из подписей является допустимой, а другая неисправна из-за ошибки в одном из возведений в степень CRT, что позволяет кому-то обнаружить один из простых множителей, что полностью решает 2-простой RSA. Защита заключается в выполнении операции с открытым ключом с использованием «e» против подписи, чтобы гарантировать, что результат соответствует исходному подписываемому сообщению. Детерминированное заполнение так же уязвимо, как и отсутствие заполнения, но такие методы, как OAEP, должны предотвратить повторный просмотр одного и того же ввода «сообщения». Silversplash ( обсуждение ) 06:56, 26 января 2023 (UTC) [ ответить ]

Мульти-простой RSA

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

Хотя в наиболее распространенном использовании RSA модуль «n» представляет собой произведение двух простых чисел, его можно использовать и как «мультипростой RSA», где «n» представляет собой произведение трех или более простых чисел.

Текущие алгоритмы факторизации зависят от размера 'n', но если простые множители достаточно велики, они не способны определить, является ли 4096-битное 'n' произведением 2 2048-битных простых чисел или произведением 4 1024-битных простых чисел. Чтобы ограничить, насколько малыми могут быть простые числа, OpenSSL ограничивает количество простых чисел на основе размера 'n', с максимальным значением по умолчанию в 5 простых чисел.

Дэниел Дж. Бернстайн описывает экстремальный постквантовый вариант многопростого RSA в https://cr.yp.to/papers/pqrsa-20170419.pdf, где «n» — это произведение огромного количества 4096-битных простых чисел, но расшифровка/подписание ускоряются с помощью вычислений CRT.

Преимущество многопростого RSA в том, что он имеет более высокую скорость без уменьшения длины бит 'n'. Потому что когда есть 'k' простых чисел одинаковой длины, есть 'k' возведений в степень чисел, размер которых равен bits(n)/k. Таким образом, вычисление CRT подписей с использованием 8192-битного 'n' может быть выполнено быстрее с CRT, если есть 4 простых числа по 2048 бит, чем CRT, когда есть 2 простых числа по 4096 бит.

Математика для RSA, которая не использует сокращение CRT, та же самая, за исключением того, что вычисления для 'phi' и 'lambda' включают умножение более двух чисел 'prime less 1', и при наличии более 2 простых чисел больше не верно, что НОК всегда является произведением простых чисел, деленных на НОД. Кроме того, больше невозможно гарантировать, что 'n' имеет правильную длину в битах, принудительно сделав верхние 2 бита всех простых чисел равными 1. Необходимо соблюдать осторожность, чтобы НОК не был значительно меньше 'n' из-за больших множителей, общих только для 2 из 3 или 4 'prime less 1's', и не отраженных в объединенном НОД.

Для многопростых RSA CRT, выполняемая OpenSSL, включает создание дополнительного d(простого) и обратного простого числа для каждого из простых чисел, превышающих сумму 2. Изменение примера статьи с 2 простыми числами для использования предварительно вычисленных переменных OpenSSL выполняется следующим образом.

1. Выберите различные простые числа p=61 q=53 r=59 s=83 (те же p и q, дополнительные r и s)
2. Вычислите 'n' = произведение всех простых чисел, n = 61 x 53 x 59 x 83 = 15832001
3. totient(n) = lcm(60,52,58,82) = 927420
4. e = 17 и проверено как взаимно простое с totient, поскольку gcd(17,927420) = 1
5. d = обратное число 17 mod 927420 = 436433, так как 436433 * 17 mod 927420 = 1
6. Открытый ключ e=17 и n=15832001, а шифрование c(m) = m^e mod n = m^17 mod 15832001
7. Если открытый текст меньше, чем p*q, то переменные CRT для 3-го и 4-го простых чисел не имеют никакого эффекта, поэтому в этом примере m=65 меняется на m=12345678.
8. Шифрование: c=12345678^17 mod 15832001 = зашифрованный текст c=8765942
9. Сокращенные переменные CRT вычисляются заранее:
d_p = d mod p-1 = 436433 mod 60 = 53 (то же самое, что и в примере с 2-мя простыми числами, потому что p такое же)
d_q = d mod q-1 = 436433 mod 52 = 49 (то же самое, что и в примере с 2-мя простыми числами, потому что q такое же)
d_r = d mod r-1 = 436433 mod 58 = 41
d_s = d mod s-1 = 436433 mod 82 = 29
10. Хотя обратное число для «q» такое же, как и в расчете с 2-мя простыми числами, предварительно вычисленные обратные числа для простых чисел после 2-го простые числа вычисляются по-разному, где значение вместо этого является обратным произведением предыдущих простых чисел, mod 'это простое число':
qInv = 1/q mod p = 53 ^-1 mod 61 = 38 (то же самое, что и в примере с 2 простыми числами)
rInv = 1/(p*q) mod r = (61*53) ^-1 mod 59 = 54
sInv = 1/(p*q*r) mod s = (61*53*59)^-1 mod 83 = 32
11. Частичные сообщения здесь помечены с использованием букв(ы) простых чисел вместо нумерации как m1 и m2, но в остальном 1-й шаг является идентичным методом для всего вычисления, когда есть 2 простых числа:

m_p = c ^ d_p mod p = 8765942^53 mod 61 = 10
m_q = c ^ d_q mod q = 8765942^49 mod 53 = 17
m_r = c ^ d_r mod r = 8765942^41 mod 59 = 46
m_s = c ^ d_s mod s = 8765942^29 mod 83 = 9

h_q = (qInv * (m_p - m_q)) mod p = (38 * (10-17)) mod 61 = 39
m_pq = (m_q + h_q * q) = 17 + 39 * 53 = 2084 (те же переменные, что и в 2-prime)

12. Для оставшихся шагов вычисления для K-го простого числа составляют h_K = Kinv * (m_K - m_(pq...K-1) ) mod K-го простого числа, а m_(pq...K) равно m_K + h_K * product_primes_previous_to_K
13. Следующий шаг расширяет вычисление 2-го простого числа шага 11 для использования переменных CRT для 3-го простого числа:
h_r = (rInv * (m_r - m_pq)) mod r = (54 * (46-2084)) mod 59 = 42
m_pqr = (m_pq + h_r * p*q) = (2084 + 42 * 61*53) = 137870
14. Следующий шаг расширяет вычисление шага № 13 для использования переменных CRT для 4-го простого числа:
h_s = (sInv * (m_s - m_pqr)) mod s = (32 * (9-137870)) mod 83 = 64
m_pqrs = (m_pqr + h_s * p*q*r) = (137870 + 64 * 61*53*59) = 12345678
Silversplash ( обсуждение ) 06:57, 26 января 2023 (UTC) [ ответить ]

«...похожи по величине, но различаются по длине».

RSA (криптосистема)#Генерация ключей Что именно это означает?

Можно ли это сделать более понятным? InverseCosine (обсуждение) 20:57, 27 марта 2023 (UTC) [ ответить ]

Хорошая новость. Я расшифровал ее. D.Lazard ( обсуждение ) 08:37, 28 марта 2023 (UTC) [ ответить ]
@D.Lazard Спасибо! Теперь это кажется более понятным представлением. InverseCosine (обсуждение) 09:09, 28 марта 2023 (UTC) [ ответить ]

RSA(криптосистема)

Привет, спасибо за этот превосходный вклад, я прочитал его на всех языках, которые я понимаю, на немецком, испанском, французском, все эти версии среди них, и в отношении вашего супервклада, вклады на других языках математически ошибочны, какой позор, основы этого алгоритма разработал Леонард Эйлер примерно в 1880 году на немецком языке, но худшие страницы о RSA Lobito060454 (обсуждение) 12:11, 4 апреля 2023 (UTC) [ ответить ]

Можете ли вы сказать, какие математические ошибки вы нашли? 62.202.182.94 (обсуждение) 13:38, 3 августа 2023 (UTC) [ ответить ]

доказательство числовое

https://www.researchgate.net/publication/374155658_High_temperature_QC_breaking_RSA-2048 2601:205:8081:BC40:4071:2248:4EE5:1D8 (обсуждение) 23:30, 4 августа 2024 (UTC) [ ответить ]

Retrieved from "https://en.wikipedia.org/w/index.php?title=Talk:RSA_(cryptosystem)&oldid=1238736339"