더 높은 성능이 필요하고 네이티브 코드 사용이 문제가 없다면, `gmpy2`와 함께 설치하도록 지정할 수 있습니다:```
pip install ecdsa[gmpy2]

## 속도

다음 표는 이 라이브러리가 키 쌍을 생성하는 데
(`keygen`), 데이터에 서명하는 데 (`sign`), 해당 서명을 검증하는 데 (`verify`),
공유 비밀 키를 도출하는 데 (`ecdh`), 그리고
키별 사전 계산 없이 서명을 검증하는 데 (`no PC verify`) 걸리는 시간을 보여줍니다.
모든 값은 초 단위입니다.
편의를 위해 해당 값들의 역수도 함께 제공됩니다:
초당 생성할 수 있는 키 수(`keygen/s`), 초당 만들 수 있는 서명 수
(`sign/s`), 초당 검증할 수 있는 서명 수
(`verify/s`), 초당 도출할 수 있는 공유 비밀 키 수
(`ecdh/s`), 그리고 키별 사전 계산 없이
초당 검증할 수 있는 서명 수(`no PC verify/s`). 원시
서명의 크기(일반적으로 서명이 인코딩될 수 있는 가장 작은
방식)도 `siglen` 열에 제공됩니다.
`tox -e speed`를 사용하여 이 표를 자신의 컴퓨터에서 생성할 수 있습니다.
Intel Core i7 4790K @ 4.0GHz에서 저는 다음과 같은 성능을 얻고 있습니다:```
                  siglen    keygen   keygen/s      sign     sign/s    verify   verify/s  no PC verify  no PC verify/s
        NIST192p:     48   0.00032s   3134.06   0.00033s   2985.53   0.00063s   1598.36       0.00129s         774.43
        NIST224p:     56   0.00040s   2469.24   0.00042s   2367.88   0.00081s   1233.41       0.00170s         586.66
        NIST256p:     64   0.00051s   1952.73   0.00054s   1867.80   0.00098s   1021.86       0.00212s         471.27
        NIST384p:     96   0.00107s    935.92   0.00111s    904.23   0.00203s    491.77       0.00446s         224.00
        NIST521p:    132   0.00210s    475.52   0.00215s    464.16   0.00398s    251.28       0.00874s         114.39
       SECP256k1:     64   0.00052s   1921.54   0.00054s   1847.49   0.00105s    948.68       0.00210s         477.01
 BRAINPOOLP160r1:     40   0.00025s   4003.88   0.00026s   3845.12   0.00053s   1893.93       0.00105s         949.92
 BRAINPOOLP192r1:     48   0.00033s   3043.97   0.00034s   2975.98   0.00063s   1581.50       0.00135s         742.29
 BRAINPOOLP224r1:     56   0.00041s   2436.44   0.00043s   2315.51   0.00078s   1278.49       0.00180s         556.16
 BRAINPOOLP256r1:     64   0.00053s   1892.49   0.00054s   1846.24   0.00114s    875.64       0.00229s         437.25
 BRAINPOOLP320r1:     80   0.00073s   1361.26   0.00076s   1309.25   0.00143s    699.29       0.00322s         310.49
 BRAINPOOLP384r1:     96   0.00107s    931.29   0.00111s    901.80   0.00230s    434.19       0.00476s         210.20
 BRAINPOOLP512r1:    128   0.00207s    483.41   0.00212s    471.42   0.00425s    235.43       0.00912s         109.61
       SECP112r1:     28   0.00015s   6672.53   0.00016s   6440.34   0.00031s   3265.41       0.00056s        1774.20
       SECP112r2:     28   0.00015s   6697.11   0.00015s   6479.98   0.00028s   3524.72       0.00058s        1716.16
       SECP128r1:     32   0.00018s   5497.65   0.00019s   5272.89   0.00036s   2747.39       0.00072s        1396.16
       SECP160r1:     42   0.00025s   3949.32   0.00026s   3894.45   0.00046s   2153.85       0.00102s         985.07
         Ed25519:     64   0.00076s   1324.48   0.00042s   2405.01   0.00109s    918.05       0.00344s         290.50
           Ed448:    114   0.00176s    569.53   0.00115s    870.94   0.00282s    355.04       0.01024s          97.69

                       ecdh     ecdh/s
        NIST192p:   0.00104s    964.89
        NIST224p:   0.00134s    748.63
        NIST256p:   0.00170s    587.08
        NIST384p:   0.00352s    283.90
        NIST521p:   0.00717s    139.51
       SECP256k1:   0.00154s    648.40
 BRAINPOOLP160r1:   0.00082s   1220.70
 BRAINPOOLP192r1:   0.00105s    956.75
 BRAINPOOLP224r1:   0.00136s    734.52
 BRAINPOOLP256r1:   0.00178s    563.32
 BRAINPOOLP320r1:   0.00252s    397.23
 BRAINPOOLP384r1:   0.00376s    266.27
 BRAINPOOLP512r1:   0.00733s    136.35
       SECP112r1:   0.00046s   2180.40
       SECP112r2:   0.00045s   2229.14
       SECP128r1:   0.00054s   1868.15
       SECP160r1:   0.00080s   1243.98

                   ecdh     ecdh/s
    NIST192p:   0.00050s   1985.70
    NIST224p:   0.00066s   1524.16
    NIST256p:   0.00071s   1413.07
    NIST384p:   0.00127s    788.89
    NIST521p:   0.00230s    434.85
   SECP256k1:   0.00071s   1409.95

(`gmpy` 버전도 있으며, `tox -e speedgmpy`로 실행할 수 있습니다.)

비교를 위해, 일부 곡선에 특화된 어셈블리를 포함한 고도로 최적화된 구현(예: OpenSSL 1.1.1d의 구현)은 동일한 머신에서 다음과 같은 성능 수치를 제공합니다.
`openssl speed ecdsa` 및 `openssl speed ecdh`를 실행하여 이를 재현하세요:```
                              sign    verify    sign/s verify/s
 192 bits ecdsa (nistp192)   0.0002s   0.0002s   4785.6   5380.7
 224 bits ecdsa (nistp224)   0.0000s   0.0001s  22475.6   9822.0
 256 bits ecdsa (nistp256)   0.0000s   0.0001s  45069.6  14166.6
 384 bits ecdsa (nistp384)   0.0008s   0.0006s   1265.6   1648.1
 521 bits ecdsa (nistp521)   0.0003s   0.0005s   3753.1   1819.5
 256 bits ecdsa (brainpoolP256r1)   0.0003s   0.0003s   2983.5   3333.2
 384 bits ecdsa (brainpoolP384r1)   0.0008s   0.0007s   1258.8   1528.1
 512 bits ecdsa (brainpoolP512r1)   0.0015s   0.0012s    675.1    860.1

                              sign    verify    sign/s verify/s
 253 bits EdDSA (Ed25519)   0.0000s   0.0001s  28217.9  10897.7
 456 bits EdDSA (Ed448)     0.0003s   0.0005s   3926.5   2147.7

                               op      op/s
 192 bits ecdh (nistp192)   0.0002s   4853.4
 224 bits ecdh (nistp224)   0.0001s  15252.1
 256 bits ecdh (nistp256)   0.0001s  18436.3
 384 bits ecdh (nistp384)   0.0008s   1292.7
 521 bits ecdh (nistp521)   0.0003s   2884.7
 256 bits ecdh (brainpoolP256r1)   0.0003s   3066.5
 384 bits ecdh (brainpoolP384r1)   0.0008s   1298.0
 512 bits ecdh (brainpoolP512r1)   0.0014s    694.8

to_string:  signkey= 24, verifykey= 48, signature=48
compressed: signkey=n/a, verifykey= 25, signature=n/a
DER:        signkey=106, verifykey= 80, signature=55
PEM:        signkey=278, verifykey=162, (no support for PEM signatures)

tox -e coverage

각 `SigningKey`/`VerifyingKey`는 NIST192p(기본값)와 같은 특정 곡선과  
연결됩니다. 더 긴 곡선은 더 안전하지만 사용하는 데 시간이 더 오래 걸리고,  
더 긴 키와 서명이 생성됩니다.```python
from ecdsa import SigningKey, NIST384p
sk = SigningKey.generate(curve=NIST384p)
vk = sk.verifying_key
signature = sk.sign(b"message")
assert vk.verify(signature, b"message")

참고: 메서드 이름은 `to_string()`이지만 실제로 반환하는 타입은 `bytes`입니다. "string"이라는 명칭은 Python 2에서 남은 것입니다.

`sk.to_pem()` 및 `sk.to_der()`는 서명 키를 OpenSSL이 사용하는 것과 동일한 형식으로 직렬화합니다. PEM 파일은 익숙한 ASCII-armored `"-----BEGIN EC PRIVATE KEY-----"` base64 인코딩 형식처럼 보이며, DER 형식은 동일한 데이터의 더 짧은 이진 형태입니다.

`SigningKey.from_pem()/.from_der()`는 이 직렬화를 되돌립니다. 이 형식에는 곡선 이름이 포함되므로 역직렬화기에 곡선 식별자를 전달할 필요가 없습니다. 파일이 손상된 경우 `from_der()` 및 `from_pem()`은 `UnexpectedDER` 또는` MalformedPointError`를 발생시킵니다.```python
from ecdsa import SigningKey, NIST384p
sk = SigningKey.generate(curve=NIST384p)
sk_pem = sk.to_pem()
sk2 = SigningKey.from_pem(sk_pem)
# sk and sk2 are the same key

서명을 계산하는 방법에는 여러 가지가 있습니다. 기본적으로 ECDSA는 서명할 데이터를 나타내는 숫자를 받아 서명을 나타내는 숫자 쌍을 반환합니다. `sk.sign()` 및 `vk.verify()`의 `hashfunc=` 인수는 임의의 문자열을 고정 길이 다이제스트로 변환한 다음 ECDSA가 서명할 수 있는 숫자로 변환하는 데 사용됩니다. 서명과 검증 모두 동일한 방식을 사용해야 합니다. 기본값은 `hashlib.sha1`이지만 NIST256p 또는 더 긴 곡선을 사용하는 경우 `hashlib.sha256`을 대신 사용할 수 있습니다.

서명을 표현하는 방법에도 여러 가지가 있습니다. 기본 `sk.sign()` 및 `vk.verify()` 메서드는 단순성과 오버헤드 최소화를 위해 서명을 짧은 문자열로 제공합니다. 다른 방식을 사용하려면 `sk.sign(sigencode=)` 및 `vk.verify(sigdecode=)` 인수를 사용하세요. `ecdsa.util` 모듈에는 여기서 유용한 헬퍼 함수가 있습니다.

또한 결정적(deterministic)인 "시드"로부터 `SigningKey`를 생성할 수도 있습니다. 이는 일관된 서명 키를 다른 비밀에서 파생하려는 프로토콜에서 사용할 수 있습니다. 예를 들어, 세 개의 별도 키가 필요하고 단일 마스터 비밀만 저장하려는 경우입니다. 약 `curve.baselen` 바이트의 엔트로피를 가진 균일하게 분포된 추측 불가능한 시드로 시작한 다음 `ecdsa.util`의 헬퍼 함수 중 하나를 사용하여 올바른 범위의 정수로 변환하고, 마지막으로 이를 `SigningKey.from_secret_exponent()`에 전달하면 됩니다. 다음과 같이:```python
import os
from ecdsa import NIST384p, SigningKey
from ecdsa.util import randrange_from_seed__trytryagain

def make_key(seed):
  secexp = randrange_from_seed__trytryagain(seed, NIST384p.order)
  return SigningKey.from_secret_exponent(secexp, curve=NIST384p)

seed = os.urandom(NIST384p.baselen) # or other starting point
sk1a = make_key(seed)
sk1b = make_key(seed)
# note: sk1a and sk1b are the same key
assert sk1a.to_string() == sk1b.to_string()
sk2 = make_key(b"2-"+seed)  # different key
assert sk1a.to_string() != sk2.to_string()

`precompute()`가 호출되면, 이 키로 수행되는 모든 서명 검증은
더 빠르게 실행됩니다.

## OpenSSL 호환성

OpenSSL 도구로 검증할 수 있는 서명을 생성하거나, 해당 도구로 생성된
서명을 검증하려면 다음을 사용하세요:```python
# openssl ecparam -name prime256v1 -genkey -out sk.pem
# openssl ec -in sk.pem -pubout -out vk.pem
# echo "data for signing" > data
# 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

import hashlib
from ecdsa import SigningKey, VerifyingKey
from ecdsa.util import sigencode_der, sigdecode_der

with open("vk.pem") as f:
   vk = VerifyingKey.from_pem(f.read())

with open("data", "rb") as f:
   data = f.read()

with open("data.sig", "rb") as f:
   signature = f.read()

assert vk.verify(signature, data, hashlib.sha256, sigdecode=sigdecode_der)

with open("sk.pem") as f:
   sk = SigningKey.from_pem(f.read(), hashlib.sha256)

new_signature = sk.sign_deterministic(data, sigencode=sigencode_der)

with open("data.sig2", "wb") as f:
   f.write(new_signature)

# openssl dgst -sha256 -verify vk.pem -signature data.sig2 data

## Entropy

`SigningKey.generate()`로 서명 키를 생성하려면 어떤 형태의
엔트로피가 필요합니다 (`from_secret_exponent`/`from_string`/`from_der`/`from_pem`과는
달리, 이들은 결정적이며 엔트로피 소스가 필요하지 않습니다). 기본
소스는 `os.urandom()`이지만, `os.urandom`처럼 동작하는 다른 함수를 `entropy=` 인자로 전달하여
다르게 동작하도록 할 수 있습니다. 이는 반복 가능한 결과를 원하는 단위 테스트에서
유용할 수 있습니다. `ecdsa.util.PRNG` 유틸리티가 여기서 유용합니다.
시드를 받아 강력한 의사 난수 스트림을 생성합니다:```python
from ecdsa.util import PRNG
from ecdsa import SigningKey
rng1 = PRNG(b"seed")
sk1 = SigningKey.generate(entropy=rng1)
rng2 = PRNG(b"seed")
sk2 = SigningKey.generate(entropy=rng2)
# sk1 and sk2 are the same key

디스크에서 서명 키를 로드하고, 이를 사용하여 메시지에 서명(SHA-1 사용)한 다음,
서명을 디스크에 기록합니다:```python
from ecdsa import SigningKey
with open("private.pem") as f:
    sk = SigningKey.from_pem(f.read())
with open("message", "rb") as f:
    message = f.read()
sig = sk.sign(message)
with open("signature", "wb") as f:
    f.write(sig)

NIST521p 키 쌍 생성:```python
from ecdsa import SigningKey, NIST521p
sk = SigningKey.generate(curve=NIST521p)
vk = sk.verifying_key

디스크에서 검증 키를 로드하고 hex 인코딩을 사용하여
비압축 및 압축 형식으로 출력합니다(X9.62 및 SEC1 표준에 정의됨):```python
from ecdsa import VerifyingKey

with open("public.pem") as f:
    vk = VerifyingKey.from_pem(f.read())

print("uncompressed: {0}".format(vk.to_string("uncompressed").hex()))
print("compressed: {0}".format(vk.to_string("compressed").hex()))

원격 상대방과의 ECDH 키 교환:```python
from ecdsa import ECDH, NIST256p

ecdh = ECDH(curve=NIST256p)
ecdh.generate_private_key()
local_public_key = ecdh.get_public_key()
#send `local_public_key` to remote party and receive `remote_public_key` from remote party
with open("remote_public_key.pem") as e:
    remote_public_key = e.read()
ecdh.load_received_public_key_pem(remote_public_key)
secret = ecdh.generate_sharedsecret_bytes()