Выбор случайного победителя в конкурсе из проголосовавших ВКонтакте

Выбор случайного победителя в конкурсе из проголосовавших ВКонтакте

{{user.first_name}}

{{#if user.paid_date}}({{user.paid_date}}){{/if}}

{{/if}} {{#if !user.first_name}}

Вход / регистрация

{{/if}} Тарифы и оплата Данные по любой ссылке из ВК Виджет активности ВК Токен расш. прав ВК Партнерка {{#if user.first_name}} Выход {{/if}}

Таргет Культиватор

— парсер ВКонтакте и Инстаграм

---

• Программа выберет в автоматическом режиме случайного победителя вашего конкурса из тех, кто проголосовал в голосовании к посту!
• Голосование ДОЛЖНО быть НЕ анонимным!
• Вы должны проголосовать в опросе, чтобы видеть резальтаты!
• Программа может автоматически выбирать победителей только из участников сообщества(от имени которого сделан пост)
• Если необходим проверить вступление в дополнительные группы — укажите их в отдельном поле(по одной в строку)
• Внимание: теперь (по нововведениям ВК) для проведения конкурса необходимо установить Токен расш. прав и нажать «Установить и использовать как основной»
• Для проведения конкурса необходимо приобрести тариф

Введите ссылку на пост

Проверять на вступление в другие сообщества

{{#if vk_groups_info. view==’repost’}}

Всего репостов: {{vk_groups_info.all_reposts}}
Репостов от пользователей: {{vk_groups_info.user_reposts}}

{{/if}} {{#if vk_groups_info.view==’comment’}}

Всего комментариев: {{vk_groups_info.all_reposts}}
Комментариев от пользователей: {{vk_groups_info.user_reposts}}

{{/if}} {{#if vk_groups_info.view==’like’}}

Всего лайков: {{vk_groups_info.user_reposts}}

{{/if}} {{#if vk_groups_info.view==’poll’}}

Всего проголосовавших: {{vk_groups_info.total_poll}}

{{#if vk_groups_info.poll_answers}}

Выбирать только из проголосовавших за ответ

Любой ответ опроса {{vk_groups_info.total_poll}}

{{#each vk_groups_info.poll_answers: nom}}

Ответ: {{ text }} {{ votes }}

{{/each}}

{{/if}}

Выбрано участников: {{vk_groups_info. user_reposts}}

{{/if}} {{#if vk_groups_info.user_reposts>0}}

Сколько победителей выбираем

{{/if}} {{#if vk_groups_info.winners}} {{#if vk_groups_info.datetime}}

Дата и время: {{vk_groups_info.datetime}}

{{/if}}

{{#if (vk_groups_info.count_winner>1) }}Победители{{else}}Победитель{{/if}}

{{#each vk_groups_info.winners: nom}}

{{#if (vk_groups_info.count_winner>1) }} {{nom+1}}. {{/if}} {{first_name}} {{last_name}} @{{screen_name}}

{{/each}}

{{/if}} {{#if vk_groups_info.winners}}

Выгрузить в виде

Имя ссылкой

Место, имя ссылкой

Имена

Ссылки

{{/if}} {{/if}}

Как выбрать случайного победителя Вконтакте — 3 способа

Конкурсы в социальных сетях – это неотъемлемая часть продвижения продукта, бренда, роста аудитории и активности. Проводить подобные мероприятия не только эффективно, но и приятно. Главное, оставаться честными при определении победителей. Как сделать последнее случайным образом, разберёмся далее в статье.

Содержание

1. Используем специальное приложение в VK
2. Использование специальных сервисов в интернете
3. Старые методы с записью на видео

Используем специальное приложение в VK

Логотип Lucky you!

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

1. RandomApp. Программа считается одной из самых прогрессивных в плане аналитики, статистики, выполнения определённых условий учёта. Для реализации случайного выбора победителя потребуется установить приложение, добавить список участников и нажать кнопку сгенерировать. Информация опубликована в группе, результаты радуют всех.
2. Lucky you! Ещё одно популярное и удобное приложение, помогающее создателям конкурса определить лучшего и случайного победителя. Опять же, для реализации поставленной задачи потребуется список и нажатие на кнопку рандомизации. Для продвинутой версии приложения создан полезный функционал, значительно упрощающий фиормирования списков.
3. Случайный победитель в розыгрыше призов – это приложение, достойное рассмотрения не только из-за названия. Сервис менее развитый, чем в предыдущем ПО, но для небольших конкурсов подойдёт на отлично.

Заметим, что это не все программы, доступные для использования. Здесь можно выделить LikeChecker, Конкурзила, Megarand и другие.

Использование специальных сервисов в интернете

Сайт random.org

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

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

Чтобы выбрать случайного участника, потребуется посетить сайт random.org или randompicker.com. Вводим количество номерков, нажимаем на кнопку рандомизации, получаем число. Теперь необходимо только свериться с порядковым номером и завершить розыгрыш.

Помните, что все должно быть честным, иначе подорванное доверие сыграет злую шутку. Для автоматизации процесса нумерации обяжите участников устанавливать номер самостоятельно под определённой записью. Человек уже будет знать, какой он по счёту и следить за результатами, а вы получите возможность быстро сформировать список.

Старые методы с записью на видео

Номерки в шапке

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

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

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

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

ecdsa · PyPI

Это простая в использовании реализация ECC (криптография на эллиптических кривых). с поддержкой ECDSA (алгоритм цифровой подписи на эллиптических кривых), EdDSA (алгоритм цифровой подписи кривой Эдвардса) и ECDH (Эллиптическая кривая Диффи-Хеллмана), реализованная исключительно на Python, выпущенная под лицензией лицензия MIT. С помощью этой библиотеки вы можете быстро создавать пары ключей (подписание ключ и ключ проверки), подписывать сообщения и проверять подписи. Ты можешь также согласовать общий секретный ключ на основе обмененных открытых ключей. Ключи и подписи очень короткие, что облегчает обращение с ними и включить в другие протоколы.

ПРИМЕЧАНИЕ. Эту библиотеку не следует использовать в рабочих настройках. Дополнительные сведения см. в разделе «Безопасность».

Функции

Эта библиотека обеспечивает генерацию ключей, подпись, проверку и общий секрет вывод на пять популярные кривые NIST «Suite B» GF(p) ( простых полей ) с длиной ключа 192, 224, 256, 384 и 521 бит. «Короткие имена» для этих кривых, известные инструмент OpenSSL ( openssl ecparam -list_curves ), это: prime192v1 , secp224r1 , prime256v1 , secp384r1 и secp521r1 . Он включает в себя 256-битная кривая secp256k1 , используемая Биткойном. Существует также поддержка обычные (нескрученные) варианты кривых Brainpool от 160 до 512 бит. «краткие имена» этих кривых: brainpoolP160r1 , brainpoolP192r1 , брейнпулP224r1 , брейнпулP256r1 ,

брейнпулP320r1 , брейнпулP384r1 , мозговой пул P512r1 . Некоторые из небольших кривых из стандарта SEC также включены (в основном для ускорения тестирования библиотеки), это: secp112r1 , secp112r2 , secp128r1 и secp160r1 . Генерация ключей, подписание и проверка также поддерживаются для Ed25519 и Кривые Ed448. Никакие другие кривые не включены, но несложно добавить поддержку большего количества кривых. кривые над простыми полями.

Зависимости

Эта библиотека использует только Python и пакет ‘six’. Он совместим с Python 2.6, 2.7 и 3.3+. Он также поддерживает выполнение на альтернативных реализации, такие как pypy и pypy3.

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

python-ecdsa обнаружит их присутствие при запуске и использует их автоматически. Вы должны предпочесть gmpy2 на Python3 для оптимальной производительности.

Для запуска тестов совместимости OpenSSL инструмент openssl должен быть в вашем ПУТЬ . Этот выпуск был успешно протестирован на OpenSSL 0.9..8o, 1.0.0a, 1.0.2f, 1.1.1d и 3.0.1 (среди прочих).

Установка

Эта библиотека доступна на PyPI, рекомендуется установить ее с помощью pip :

 pip install ecdsa
 

Если требуется более высокая производительность и использование собственного кода не является проблемой, можно указать установку вместе с gmpy2 :

 pip install ecdsa[gmpy2]
 

или (медленнее, устаревший вариант):

 pip install ecdsa[gmpy]
 

Скорость

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

( keygen ), для подписи данных (, знак ), для проверки этих подписей (, проверка ), для получения общего секрета ( ecdh ) и для проверки подписей без предварительного вычисления ключа ( без проверки ПК ). Все эти значения указаны в секундах. Для удобства также предусмотрены инверсии этих значений: сколько ключей в секунду может быть сгенерировано ( keygen/s ), сколько подписей может быть сделано в секунду ( знаков / с ), сколько подписей можно проверить в секунду ( verify/s ), сколько общих секретов может быть получено в секунду ( ecdh/s ) и сколько подписей без конкретного ключа предварительные вычисления могут быть проверены в секунду ( без проверки ПК/с ). Размер сырья подпись (как правило, самая маленькая способ кодирования подписи) также указан в столбце siglen . Используйте tox -e скорость , чтобы создать эту таблицу на своем компьютере. На Intel Core i7 4790K @ 4,0 ГГц я получаю следующую производительность:

 siglen keygen keygen/s знак знак/ы проверить проверить/с нет проверки ПК нет проверки ПК
        NIST192p: 48 0,00032 с 3134,06 0,00033 с 2985,53 0,00063 с 1598,36 0,00129 с 774,43
        NIST224p: 56 0,00040 с 2469,24 0,00042 с 2367,88 0,00081 с 1233,41 0,00170 с 586,66
        NIST256p: 64 0,00051 с 1952,73 0,00054 с 1867,80 0,00098 с 1021,86 0,00212 с 471,27
        NIST384p: 96 0,00107 с 935,92 0,00111 с 904,23 0,00203 с 491,77 0,00446 с 224,00
        NIST521p: 132 0,00210 с 475,52 0,00215 с 464,16 0,00398 с 251,28 0,00874 с 114,39
       SECP256k1: 64 0,00052 с 1921,54 0,00054 с 1847,49 0,00105 с 948,68 0,00210 с 477,01
 BRAINPOOLP160r1: 40 0,00025 с 4003,88 0,00026 с 3845,12 0,00053 с 1893,93 0,00105 с 949,92
 BRAINPOOLP192r1: 48 0,00033 с 3043,97 0,00034 с 2975,98 0,00063 с 1581,50 0,00135 с 742,29
 BRAINPOOLP224r1: 56 0,00041 с 2436,44 0,00043 с 2315,51 0,00078 с 1278,49 0,00180 с 556,16
 BRAINPOOLP256r1: 64 0,00053 с 1892,49 0,00054 с 1846,24 0,00114 с 875,64 0,00229 с 437,25
 BRAINPOOLP320r1: 80 0,00073 с 1361,26 0,00076 с 1309,25 0,00143 с 699,29 0,00322 с 310,49BRAINPOOLP384r1: 96 0,00107 с 931,29 0,00111 с 901,80 0,00230 с 434,19 0,00476 с 210,20
 BRAINPOOLP512r1: 128 0,00207 с 483,41 0,00212 с 471,42 0,00425 с 235,43 0,00912 с 109,61
       SECP112r1: 28 0,00015 с 6672,53 0,00016 с 6440,34 0,00031 с 3265,41 0,00056 с 1774,20
       SECP112r2: 28 0,00015 с 6697,11 0,00015 с 6479,98 0,00028 с 3524,72 0,00058 с 1716,16
       SECP128r1: 32 0,00018 с 5497,65 0,00019 с 5272,89 0,00036 с 2747,39 0,00072 с 1396,16
       SECP160r1: 42 0,00025 с 3949,32 0,00026 с 3894,45 0,00046 с 2153,85 0,00102 с 985,07
         Ed25519: 64 0,00076 с 1324,48 0,00042 с 2405,01 0,00109 с 918,05 0,00344 с 290,50
           Ed448: 114 0,00176 с 569,53 0,00115 с 870,94 0,00282 с 355,04 0,01024 с 97,69
                       ecdh ecdh/с
        NIST192p: 0,00104 с 964,89
        NIST224p: 0,00134 с 748,63
        NIST256p: 0,00170 с 587,08
        NIST384p: 0,00352 с 283,90
        NIST521p: 0,00717 с 139,51
       SECP256k1: 0,00154 с 648,40
 BRAINPOOLP160r1: 0,00082 с 1220,70
 BRAINPOOLP192r1: 0,00105 с 956,75
 BRAINPOOLP224r1: 0,00136 с 734,52
 BRAINPOOLP256r1: 0,00178 с 563,32
 BRAINPOOLP320r1: 0,00252 с 397,23
 BRAINPOOLP384r1: 0,00376 с 266,27
 BRAINPOOLP512r1: 0,00733 с 136,35
       SECP112r1: 0,00046 с 2180,40
       SECP112r2: 0,00045 с 2229. 14
       SECP128r1: 0,00054 с 1868,15
       SECP160r1: 0,00080 с 1243,98
 

Чтобы проверить производительность с загруженным gmpy2 , используйте tox -e speedgmpy2 . На той же машине я получаю следующую производительность с gmpy2 :

 siglen keygen keygen/s знак знак/ы проверить проверить/с нет проверки ПК нет проверки ПК/с
        NIST192p: 48 0,00017 с 5933,40 0,00017 с 5751,70 0,00032 с 3125,28 0,00067 с 1502,41
        NIST224p: 56 0,00021 с 4782,87 0,00022 с 4610,05 0,00040 с 2487,04 0,00089с 1126,90
        NIST256p: 64 0,00023 с 4263,98 0,00024 с 4125,16 0,00045 с 2200,88 0,00098 с 1016,82
        NIST384p: 96 0,00041 с 2449,54 0,00042 с 2399,96 0,00083 с 1210,57 0,00172 с 581,43
        NIST521p: 132 0,00071 с 1416,07 0,00072 с 1389,81 0,00144 с 692,93 0,00312 с 320,40
       SECP256k1: 64 0,00024 с 4245,05 0,00024 с 4122,09 0,00045 с 2206,40 0,00094 с 1068,32
 BRAINPOOLP160r1: 40 0,00014 с 6939,17 0,00015 с 6681,55 0,00029 с 3452,43 0,00057 с 1769,81
 BRAINPOOLP192r1: 48 0,00017 с 5920,05 0,00017 с 5774,36 0,00034 с 2979,00 0,00069 с 1453,19
 BRAINPOOLP224r1: 56 0,00021 с 4732,12 0,00022 с 4622,65 0,00041 с 2422,47 0,00087 с 1149,87
 BRAINPOOLP256r1: 64 0,00024 с 4233,02 0,00024 с 4115,20 0,00047 с 2143,27 0,00098 с 1015,60
 BRAINPOOLP320r1: 80 0,00032 с 3162,38 0,00032 с 3077,62 0,00063 с 1598,83 0,00136 с 737,34
 BRAINPOOLP384r1: 96 0,00041 с 2436,88 0,00042 с 2395,62 0,00083 с 1202,68 0,00178 с 562,85
 BRAINPOOLP512r1: 128 0,00063 с 1587,60 0,00064 с 1558,83 0,00125 с 799,96 0,00281 с 355,83
       SECP112r1: 28 0,00009 с 11118,66 0,00009 с 10775,48 0,00018 с 5456,00 0,00033 с 3020,83
       SECP112r2: 28 0,00009 с 11322,97 0,00009 с 10857,71 0,00017 с 5748,77 0,00032 с 3094,28
       SECP128r1: 32 0,00010 с 10078,39 0,00010 с 9665,27 0,00019 с 5200,58 0,00036 с 2760,88
       SECP160r1: 42 0,00015 с 6875,51 0,00015 с 6647,35 0,00029 с 3422,41 0,00057 с 1768,35
         Ed25519: 64 0,00030 с 3322,56 0,00018 с 5568,63 0,00046 с 2165,35 0,00153 с 654,02
           Ed448: 114 0,00060 с 1680,53 0,00039 с 2567,40 0,00096 с 1036,67 0,00350 с 285,62
                       ecdh ecdh/с
        NIST192р: 0,00050 с 1985,70
        NIST224p: 0,00066 с 1524,16
        NIST256p: 0,00071 с 1413,07
        NIST384p: 0,00127 с 788,89
        NIST521p: 0,00230 с 434,85
       SECP256k1: 0,00071 с 1409,95
 BRAINPOOLP160r1: 0,00042 с 2374,65
 BRAINPOOLP192r1: 0,00051 с 1960,01
 BRAINPOOLP224r1: 0,00066 с 1518,37
 BRAINPOOLP256r1: 0,00071 с 1399,90
 BRAINPOOLP320r1: 0,00100 с 997,21
 BRAINPOOLP384r1: 0,00129 с 777,51
 BRAINPOOLP512r1: 0,00210 с 475,99
       SECP112r1: 0,00022 с 4457,70
       SECP112r2: 0,00024 с 4252,33
       SECP128r1: 0,00028 с 3589. 31
       SECP160r1: 0,00043 с 2305,02
 

(есть также версия gmpy , запустите ее с помощью tox -e speedgmpy )

Для сравнения, высокооптимизированная реализация (включая специфичную для кривой сборки для некоторых кривых), например, в OpenSSL 1.1.1d, обеспечивает следующие показатели производительности на той же машине. Запустите openssl speed ecdsa и openssl speed ecdh , чтобы воспроизвести его:

 проверка подписи проверка подписи/с
 192 бита ecdsa (nistp192) 0,0002 с 0,0002 с 4785,6 5380,7
 224 бита ecdsa (nistp224) 0,0000 с 0,0001 с 22475,6 9822,0
 256 бит ecdsa (nistp256) 0,0000 с 0,0001 с 45069,6 14166,6
 384 бит ecdsa (nistp384) 0,0008 с 0,0006 с 1265,6 1648,1
 521 бит ecdsa (nistp521) 0,0003 с 0,0005 с 3753,1 1819,5
 256 бит ecdsa (brainpoolP256r1) 0,0003 с 0,0003 с 2983,5 3333,2
 384-битный ecdsa (brainpoolP384r1) 0,0008 с 0,0007 с 1258,8 1528,1
 512 бит ecdsa (brainpoolP512r1) 0,0015 с 0,0012 с 675,1 860,1
                              подписать подтвердить подписать/и проверить/и
 253 бит EdDSA (Ed25519) 0,0000 с 0,0001 с 28 217,9 10 897,7
 456 бит EdDSA (Ed448) 0,0003 с 0,0005 с 3926,5 2147,7
                               оп оп/с
 192 бита ecdh (nistp192) 0,0002 с 4853,4
 224 бита ecdh (nistp224) 0,0001 с 15252,1
 256 бит ecdh (nistp256) 0,0001 с 18436,3
 384 бита ecdh (nistp384) 0,0008 с 1292,7
 521 бит ecdh (nistp521) 0,0003 с 2884,7
 256 бит ecdh (brainpoolP256r1) 0,0003 с 3066,5
 384-битный ecdh (brainpoolP384r1) 0,0008 с 1298,0
 512 бит ecdh (brainpoolP512r1) 0,0014 с 694,8
 

Ключи и подпись можно сериализовать по-разному (см. Использование ниже). Для ключа NIST192p для трех основных представлений требуются строки следующие длины (в байтах):

 to_string: signkey= 24, verifykey= 48, подпись=48
сжато: ключ подписи = н/д, ключ проверки = 25, подпись = н/д
DER: ключ подписи = 106, ключ проверки = 80, подпись = 55
PEM: signkey=278, verifykey=162 (нет поддержки подписей PEM)
 

История

В 2006 году Питер Пирсон объявил о своей реализации ECDSA на чистом Python в сообщение для sci.crypt, доступное на его сайте загрузки. В 2010, Брайан Уорнер написал обертку вокруг этого кода, чтобы сделать его немного проще и удобнее. безопаснее в использовании. В 2020 году Хьюберт Карио включил реализацию эллиптического кривая криптография, которая использует внутренние координаты Якоби, улучшая производительность примерно в 20 раз. Вы просматриваете README для этой оболочки.

Тестирование

Чтобы запустить полный набор тестов, сделайте следующее:

 покрытие tox -e
 

На Intel Core i7 4790K @ 4,0 ГГц выполнение тестов занимает около 18 секунд. В наборе тестов используется гипотеза так что есть некоторые присущая изменчивость во времени выполнения набора тестов.

Одна часть test_pyecdsa.py и test_ecdh.py проверяет совместимость с OpenSSL, запустив инструмент командной строки «openssl», убедитесь, что он находится в вашем PATH если вы хотите проверить совместимость с ним (если OpenSSL отсутствует, слишком стар или не поддерживает все кривые, поддерживаемые в вышестоящих выпусках, которые вы увидите пропущенные тесты в приведенном выше покрытии запуска).

Безопасность

Эта библиотека не была разработана с учетом требований безопасности. Если вы обрабатываете данные, которые необходимо защитить, мы предлагаем вам использовать качественную оболочку вокруг OpenSSL. pyca/cryptography — один из примеров таких обертка. Основной вариант использования этой библиотеки — переносная библиотека для тестирование функциональной совместимости и в качестве учебного пособия.

Эта библиотека не защищает от атак по сторонним каналам.

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

Также обратите внимание, что любая криптографическая библиотека Pure-python будет уязвима к тем же атакам по сторонним каналам. Это потому, что Python не предоставляет безопасные примитивы по побочному каналу (за исключением hmac.compare_digest() ), что делает программирование по сторонним каналам безопасным невозможный.

Эта библиотека зависит от надежного источника случайных чисел. Не используйте его на система где os.urandom() не обеспечивает криптографическую защиту случайные числа.

Usage

Вы начинаете с создания SigningKey . Вы можете использовать это для подписи данных, передав в данных в виде строки байтов и получения подписи (также строки байтов). Вы также можете попросить SigningKey предоставить вам соответствующий VerifyingKey . VerifyingKey можно использовать для проверки подписи, передав его как строка данных и строка байта подписи: она либо возвращает True, либо вызывает BadSignatureError .

 из импорта ecdsa SigningKey
sk = SigningKey.generate() # использует NIST192p
vk = sk. verifying_key
подпись = sk.sign(b"сообщение")
утверждать vk.verify(подпись, б"сообщение")
 

Каждый SigningKey / VerifyingKey связан с определенной кривой, например NIST192p (по умолчанию). Более длинные повороты более безопасны, но требуют больше времени для использования и приводят к более длинным ключам и подписям.

 из импорта ecdsa SigningKey, NIST384p
sk = SigningKey.generate (кривая = NIST384p)
vk = sk.verifying_key
подпись = sk.sign(b"сообщение")
утверждать vk.verify(подпись, б"сообщение")
 

SigningKey может быть сериализован в несколько различных форматов: самый короткий заключается в вызове s=sk.to_string() , а затем воссоздании его с помощью SigningKey.from_string(s, curve) . Эта краткая форма не записывает кривой, поэтому вы должны обязательно передать from_string() ту же самую кривую, которую вы использовали для оригинального ключа. Краткая форма ключа подписи на основе NIST192p — всего 24 байты длинные. Если кодировка точки недействительна или не лежит на указанном кривая, from_string() вызовет MalformedPointError .

 из импорта ecdsa SigningKey, NIST384p
sk = SigningKey.generate (кривая = NIST384p)
sk_string = sk.to_string()
sk2 = SigningKey.from_string (sk_string, кривая = NIST384p)
печать (sk_string.hex())
печать (sk2.to_string().hex())
 

Примечание: хотя методы вызываются to_string() , они возвращают тип на самом деле байт , «строковая» часть осталась от Python 2.

sk.to_pem() и sk.to_der() сериализует ключ подписи в один и тот же форматы, которые использует OpenSSL. Файл PEM выглядит как знакомый файл в формате ASCII. "-----BEGIN EC PRIVATE KEY-----" формат с кодировкой base64 и формат DER является более короткой двоичной формой тех же данных. SigningKey.from_pem()/.from_der() отменит эту сериализацию. Эти форматы включают имя кривой, поэтому вам не нужно передавать кривую идентификатор десериализатору. Если файл поврежден from_der() и from_pem() вызовет UnexpectedDER или MalformedPointError .

 из импорта ecdsa SigningKey, NIST384p
sk = SigningKey.generate (кривая = NIST384p)
sk_pem = sk.to_pem()
sk2 = Ключ подписи.from_pem(sk_pem)
# sk и sk2 - это один и тот же ключ
 

Таким же образом можно сериализовать VerifyingKey : vk.to_string()/VerifyingKey.from_string() , to_pem()/from_pem() и to_der()/from_der() . Тот же аргумент curve= необходим VerifyingKey.from_string() .

 из импорта ecdsa SigningKey, VerifyingKey, NIST384p
sk = SigningKey.generate (кривая = NIST384p)
vk = sk.verifying_key
vk_string = vk.to_string()
vk2 = VerifyingKey.from_string(vk_string, кривая=NIST384p)
# vk и vk2 это один и тот же ключ
из ecdsa импортировать SigningKey, VerifyingKey, NIST384p
sk = SigningKey.generate (кривая = NIST384p)
vk = sk. verifying_key
vk_pem = vk.to_pem()
vk2 = VerifyingKey.from_pem(vk_pem)
# vk и vk2 это один и тот же ключ
 

Существует несколько способов вычисления подписи. В корне, ECDSA принимает число, представляющее подписываемые данные, и возвращает пара чисел, представляющих подпись. Аргумент hashfunc= для sk.sign() и vk.verify() используется для преобразования произвольной строки в дайджест фиксированной длины, который затем преобразуется в число, которое может подписывать ECDSA, и для подписи, и для проверки должен использоваться один и тот же подход. Значение по умолчанию hashlib.sha1 , но если вы используете NIST256p или более длинную кривую, вы можете использовать Вместо hashlib.sha256 .

Существует также несколько способов представления подписи. По умолчанию sk.sign() и методы vk.verify() представляют его в виде короткой строки, для простота и минимальные накладные расходы. Чтобы использовать другую схему, используйте sk.sign(sigencode=) и vk.verify(sigdecode=) аргументов. Есть помощник функции в модуле ecdsa.util , которые могут быть здесь полезны.

Также возможно создать SigningKey из «начального числа», которое детерминированный. Это можно использовать в протоколах, где вы хотите получить согласованные ключи подписи из какого-то другого секрета, например, когда вы хотите три отдельных ключа и хотят хранить только один главный секрет. Вам следует начните с равномерно распределенного неугадываемого начального числа примерно с curve.baselen байтов энтропии, а затем используйте одну из вспомогательных функций в ecdsa.util для преобразовать его в целое число в правильном диапазоне, а затем, наконец, передать его в SigningKey.from_secret_exponent() , например:

 import os
из ecdsa импортировать NIST384p, SigningKey
из ecdsa. util импортировать randrange_from_seed__trytryagain
определение make_key (начальное число):
  secexp = randrange_from_seed__trytryagain(seed, NIST384p.order)
  вернуть SigningKey.from_secret_exponent (secexp, кривая = NIST384p)
seed = os.urandom(NIST384p.baselen) # или другая отправная точка
sk1a = make_key (начальное число)
sk1b = make_key (начальное число)
# примечание: sk1a и sk1b - это один и тот же ключ
утверждать sk1a.to_string() == sk1b.to_string()
sk2 = make_key(b"2-"+seed) # другой ключ
утверждать sk1a.to_string() != sk2.to_string()
 

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

Для выполнения предварительных вычислений можно вызвать метод precompute() . на экземпляре VerifyingKey :

 из импорта ecdsa SigningKey, NIST384p
sk = SigningKey. generate (кривая = NIST384p)
vk = sk.verifying_key
vk.precompute()
подпись = sk.sign(b"сообщение")
утверждать vk.verify(подпись, б"сообщение")
 

После вызова precompute() все проверки подписи с этим ключом будут быть быстрее в исполнении.

Совместимость с OpenSSL

Для создания подписей, которые можно проверить средствами OpenSSL, или для проверки подписи, созданные этими инструментами, используйте:

 # openssl ecparam -name prime256v1 -genkey -out sk.pem
# openssl ec -in sk.pem -pubout -out vk.pem
# echo "данные для подписи" > данные
# openssl dgst -sha256 -sign sk.pem -out data.sig data
# openssl dgst -sha256 -verify vk.pem -signature data.sig data
# openssl dgst -sha256 -prverify sk.pem -signature data.sig data
импортировать хеш-библиотеку
из ecdsa импортировать SigningKey, VerifyingKey
из ecdsa.util импортировать sigencode_der, sigdecode_der
с open("vk.pem") как f:
   vk = VerifyingKey.from_pem(f.read())
с open("data", "rb") как f:
   данные = f. read()
с open("data.sig", "rb") как f:
   подпись = f.read()
утверждать vk.verify(подпись, данные, hashlib.sha256, sigdecode=sigdecode_der)
с open("sk.pem") как f:
   sk = SigningKey.from_pem(f.read(), hashlib.sha256)
new_signature = sk.sign_deterministic (данные, sigencode = sigencode_der)
с open("data.sig2", "wb") как f:
   f.write (новая_подпись)
# openssl dgst -sha256 -verify vk.pem -signature data.sig2 data
 

Примечание: если необходима совместимость с OpenSSL 1.0.0 или более ранней sigencode_string и sigdecode_string из ecdsa.util можно использовать для соответственно запись и чтение подписей.

Ключи также могут быть записаны в формате, который поддерживает openssl:

 из ecdsa import SigningKey, VerifyingKey
с open("sk.pem") как f:
    sk = SigningKey.from_pem(f.read())
с open("sk.pem", "wb") как f:
    f.write(sk.to_pem())
с open("vk.pem") как f:
    vk = VerifyingKey.from_pem(f.read())
с open("vk. pem", "wb") как f:
    f.write(vk.to_pem())
 

Entropy

Для создания ключа подписи с помощью SigningKey.generate() требуется некоторая форма энтропия (в отличие от from_secret_exponent / from_string / from_der / from_pem , которые являются детерминированными и не требуют источника энтропии). По умолчанию источник os.urandom() , но вы можете передать любую другую функцию, которая ведет себя например, os.urandom в качестве аргумента энтропия = , чтобы сделать что-то другое. Этот может быть полезно в модульных тестах, где вы хотите добиться воспроизводимых результатов. 9Утилита 0015 ecdsa.util.PRNG здесь удобна: она берет семя и выдает сильное псевдослучайный поток из него:

 из ecdsa.util import PRNG
из ecdsa импортировать SigningKey
rng1 = PRNG(b"seed")
sk1 = SigningKey.generate (энтропия = rng1)
rng2 = PRNG(b"seed")
sk2 = SigningKey. generate (энтропия = rng2)
# sk1 и sk2 - это один и тот же ключ
 

Аналогично, для генерации подписи ECDSA требуется случайное число, и каждый подпись должна быть другой (использование одного и того же номера дважды немедленно раскрыть закрытый ключ подписи). Метод sk.sign() принимает entropy= аргумент, который ведет себя так же, как SigningKey.generate(entropy=) .

Детерминированные подписи

Если вы вызываете SigningKey.sign_deterministic(data) вместо .sign(data) , код будет генерировать детерминированную подпись вместо случайной. Здесь используется алгоритм из RFC6979 для безопасного создания уникального значения k , полученный из закрытого ключа и подписываемого сообщения. Каждый раз, когда вы подписываете одно и то же сообщение с тем же ключом, вы получите ту же подпись (используя то же самое к ).

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

Примеры

Создайте пару ключей NIST192p и немедленно сохраните оба на диск:

 из ecdsa import SigningKey
sk = SigningKey.generate()
vk = sk.verifying_key
с open("private.pem", "wb") как f:
    f.write(sk.to_pem())
с open("public.pem", "wb") как f:
    f.write(vk.to_pem())
 

Загрузите ключ подписи с диска, используйте его для подписи сообщения (используя SHA-1) и напишите подпись к диску:

 из импорта ecdsa SigningKey
с open("private.pem") как f:
    sk = SigningKey.from_pem(f.read())
с open("сообщение", "rb") как f:
    сообщение = f.read()
sig = sk.sign(сообщение)
с open("signature", "wb") как f:
    f.написать (подписать)
 

Загрузите ключ проверки, сообщение и подпись с диска и проверьте подпись (предположим, хэш SHA-1):

 из ecdsa import VerifyingKey, BadSignatureError
vk = VerifyingKey.from_pem(open("public.pem").read())
с open("сообщение", "rb") как f:
    сообщение = f.read()
с open("signature", "rb") как f:
    сигнал = f. read()
пытаться:
    vk.verify(подпись, сообщение)
    печатать "хорошая подпись"
кроме BadSignatureError:
    печать "ПЛОХАЯ ПОДПИСЬ"
 

Создайте пару ключей NIST521p:

 из ecdsa import SigningKey, NIST521p
sk = SigningKey.generate (кривая = NIST521p)
vk = sk.verifying_key
 

Создайте три независимых ключа подписи из основного начального числа:

 из ecdsa import NIST192p, SigningKey
из ecdsa.util импортировать randrange_from_seed__trytryagain
def make_key_from_seed (начальное значение, кривая = NIST192p):
    secexp = randrange_from_seed__trytryagain(начальное число, кривая.порядок)
    вернуть SigningKey.from_secret_exponent(secexp, кривая)
sk1 = make_key_from_seed("1:%s" % seed)
sk2 = make_key_from_seed("2:%s" % seed)
sk3 = make_key_from_seed("3:%s" % seed)
 

Загрузите ключ проверки с диска и распечатайте его, используя шестнадцатеричное кодирование в несжатый и сжатый формат (определено в стандартах X9.62 и SEC1):

 из ecdsa import VerifyingKey
с open("public.