Hướng dẫn ecdsa secp256k1 python - trăn ecdsa secp256k1

Question

x = 0x887387E452B8EACC4ACFDE10D9AAF7F6D9A0F975AABB10D006E4DA568744D06C,=0x887387E452B8EACC4ACFDE10D9AAF7F6D9A0F975AABB10D006E4DA568744D06C,

Nội dung chính Show

Pure-Python ECDSA và ECDH
Đặc trưng
Phụ thuộc
Cài đặt
Tốc độ, vận tốc
Lịch sử
Cách sử dụng
Khả năng tương thích OpenSSL
Sự hỗn loạn
Chữ ký xác định

y = 0x61DE6D95231CD89026E286DF3B6AE4A894A3378E393E93A0F45B666329A0AE34,=0x61DE6D95231CD89026E286DF3B6AE4A894A3378E393E93A0F45B666329A0AE34,

# Trường hợp kiểm tra 1: Xác minh tính xác thực

Z = 0xEC208BAA0FC1C19F708A9CA96FDEF3AC3F230BB4A7BA4AEDE4942AD003C0F60=0xEC208BAA0FC1C19F708A9CA96FDEFF3AC3F230BB4A7BA4AEDE4942AD003C0F60

r = 0xAC8D1C87E51D0D441BE8B3DD5B05C8795B48875DFFE00B7FFCFAC23010D3A395=0xAC8D1C87E51D0D441BE8B3DD5B05C8795B48875DFFE00B7FFCFAC23010D3A395

S = 0x68342ceff8935EdDD102DD876FFD6BA72D6A427A3EDB13D26EB0781CB423C4=0x68342CEFF8935EDEDD102DD876FFD6BA72D6A427A3EDB13D26EB0781CB423C4

khẳng định chữ ký (R, S) .verify (Z, Pub) Signature(r, s).verify(z, pub)

# Trường hợp kiểm tra 2: Xác minh tính xác thực cho chữ ký khác nhau w/ cùng một p

Z = 0x7C076FF316692A3D7EB3C3BB0F8B1488CF72E1AFCD929E29307032997A838A3D=0x7C076FF316692A3D7EB3C3BB0F8B1488CF72E1AFCD929E29307032997A838A3D

r = 0xeff69ef2b1bd93a66ed5219add4fb51e11a840f404876325a1e8ffe0529a2c=0xEFF69EF2B1BD93A66ED5219ADD4FB51E11A840F404876325A1E8FFE0529A2C

S = 0xC7207FEE197D27C618AEA621406F6BF5EF6FCA38681D82B2F06FDDDBDCE6FEAB6= 0xC7207FEE197D27C618AEA621406F6BF5EF6FCA38681D82B2F06FDDBDCE6FEAB6

khẳng định chữ ký (R, S) .verify (Z, Pub) Signature(r, s).verify(z, pub)

# Trường hợp kiểm tra 2: Xác minh tính xác thực cho chữ ký khác nhau w/ cùng một p

Z = 0x7C076FF316692A3D7EB3C3BB0F8B1488CF72E1AFCD929E29307032997A838A3D= PrivateKey(randint(0, N)) # generate a private key

r = 0xeff69ef2b1bd93a66ed5219add4fb51e11a840f404876325a1e8ffe0529a2c= e.secret * G # public point corresponding to e

S = 0xC7207FEE197D27C618AEA621406F6BF5EF6FCA38681D82B2F06FDDDBDCE6FEAB6= randint(0, 2** 256)# generate a random message for testing

# Trường hợp kiểm tra 3: ký và xác minh: Signature = e.sign(z)

e = privateKey (randint (0, n))# tạo khóa riêng signature.verify(z, pub)

2

Mới! Lưu câu hỏi hoặc câu trả lời và sắp xếp nội dung yêu thích của bạn. Tìm hiểu thêm.Learn more.
Learn more.

Nếu tôi tạo khóa công khai trực tiếp từ việc ký khóa với

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

9

Nó hoạt động tốt và xác minh nó, nhưng nếu tôi cố gắng tạo khóa công khai theo cách thủ công với

pip install ecdsa

0 vì một số lý do, nó không xác minh nó và trả về sai.

Sao chép Dán mã sau và Chạy Bạn sẽ quan sát sự khác biệt kỳ lạ

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

Những gì tôi mong đợi là đầu ra thực sự từ cả hai bài kiểm tra.

Khi được hỏi ngày 6 tháng 5 năm 2019 lúc 23:30May 6, 2019 at 23:30May 6, 2019 at 23:30

lastpeony4lastpeony4lastpeony4lastpeony4

5137 Huy hiệu bạc22 Huy hiệu Đồng7 silver badges22 bronze badges7 silver badges22 bronze badges

Bạn đã thiếu

pip install ecdsa

1 trong

pip install ecdsa

2, mặc định là

pip install ecdsa

3.

Thử

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

Kết quả:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

Đã trả lời ngày 6 tháng 5 năm 2019 lúc 23:41May 6, 2019 at 23:41May 6, 2019 at 23:41

XarvalusxarvalusXarvalusXarvalus

2.5571 Huy hiệu vàng19 Huy hiệu bạc29 Huy hiệu đồng1 gold badge19 silver badges29 bronze badges1 gold badge19 silver badges29 bronze badges

Pure-Python ECDSA và ECDH

Đây là một triển khai dễ sử dụng của ECC (mật mã đường cong hình elip) với sự hỗ trợ cho ECDSA (Thuật toán chữ ký kỹ thuật số đường cong hình elip), EDDSA (thuật toán chữ ký kỹ thuật số Edwards-Curve) và ECDH (đường cong hình elip khác nhau) Python, được phát hành theo giấy phép MIT. Với thư viện này, bạn có thể nhanh chóng tạo các cặp khóa (Key Key và Xác minh khóa), ký tin nhắn và xác minh chữ ký. Bạn cũng có thể đồng ý về khóa bí mật chung dựa trên các khóa công khai được trao đổi. Các phím và chữ ký rất ngắn, giúp chúng dễ dàng xử lý và kết hợp vào các giao thức khác.

Lưu ý: Thư viện này không nên được sử dụng trong cài đặt sản xuất, xem bảo mật để biết thêm chi tiết.

Đặc trưng

Thư viện này cung cấp tạo ra, việc ký kết, xác minh và chia sẻ nguồn gốc bí mật cho năm đường cong "Suite B" GF (P) (P) phổ biến của NIST, với độ dài chính là 192, 224, 256, 384 và 521 bit. "Tên ngắn" cho các đường cong này, như được biết đến bởi Công cụ OpenSSL (

pip install ecdsa

4), là:

pip install ecdsa

5,

pip install ecdsa

6,

pip install ecdsa

7,

pip install ecdsa

8 và

pip install ecdsa

9. Nó bao gồm đường cong 256 bit

pip install ecdsa

40 được sử dụng bởi Bitcoin. Ngoài ra còn có sự hỗ trợ cho các biến thể thường xuyên (không twist) của các đường cong Brainpool từ 160 đến 512 bit. "Tên ngắn" của các đường cong đó là:

pip install ecdsa

41,

pip install ecdsa

42,

pip install ecdsa

43,

pip install ecdsa

44,

pip install ecdsa

45,

pip install ecdsa

46,

pip install ecdsa

47. Một vài trong số các đường cong nhỏ từ tiêu chuẩn SEC cũng được bao gồm (chủ yếu là thử nghiệm tăng tốc của thư viện), đó là:

pip install ecdsa

48,

pip install ecdsa

49,

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

40 và

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

41. Tạo chính, Siging và Xác minh cũng được hỗ trợ cho các đường cong ED25519 và ED448. Không có đường cong nào khác được bao gồm, nhưng không quá khó để thêm hỗ trợ cho nhiều đường cong hơn các trường chính.

Phụ thuộc

Thư viện này chỉ sử dụng Python và gói 'sáu'. Nó tương thích với Python 2.6, 2.7 và 3.3+. Nó cũng hỗ trợ thực hiện trên các triển khai thay thế như Pypy và Pypy3.

Nếu

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

42 hoặc

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

43 được cài đặt, chúng sẽ được sử dụng để số học nhanh hơn. Một trong số chúng có thể được cài đặt sau khi thư viện này được cài đặt,

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

44 sẽ phát hiện sự hiện diện của chúng khi khởi động và sử dụng chúng tự động. Bạn nên thích

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

42 trên Python3 để có hiệu suất tối ưu.

Để chạy các thử nghiệm tương thích OpenSSL, công cụ 'openSSL' phải có trong

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

46 của bạn. Bản phát hành này đã được thử nghiệm thành công so với OpenSSL 0.9.8o, 1.0.0a, 1.0.2f, 1.1.1D và 3.0.1 (trong số những người khác).

Cài đặt

Thư viện này có sẵn trên PYPI, nên cài đặt nó bằng cách sử dụng

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

47:

pip install ecdsa

Trong trường hợp có hiệu suất cao hơn và sử dụng mã gốc không phải là vấn đề, có thể chỉ định cài đặt cùng với

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

42:

pip install ecdsa

4

hoặc (tùy chọn chậm hơn, kế thừa):

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

4

Tốc độ, vận tốc

Bảng sau đây cho thấy thư viện này mất bao lâu để tạo các cặp khóa (

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

49), để ký dữ liệu (

pip install ecdsa

70), để xác minh các chữ ký đó (

pip install ecdsa

71), để lấy bí mật chia sẻ (

pip install ecdsa

72) và để xác minh chữ ký không có khóa- Tiền định cụ thể (

pip install ecdsa

73). Tất cả những giá trị đó là trong giây. Để thuận tiện, nghịch đảo của các giá trị đó cũng được cung cấp: có thể tạo bao nhiêu phím mỗi giây (

pip install ecdsa

74), có thể thực hiện bao nhiêu chữ ký mỗi giây (

pip install ecdsa

75), có bao nhiêu chữ ký có thể được xác minh mỗi giây (

pip install ecdsa

76) Bí mật được chia sẻ có thể được lấy từ mỗi giây (

pip install ecdsa

77) và có bao nhiêu chữ ký không có tính toán cụ thể quan trọng có thể được xác minh mỗi giây (

pip install ecdsa

78). Kích thước của chữ ký thô (nói chung là nhỏ nhất cách một chữ ký có thể được mã hóa) cũng được cung cấp trong cột

pip install ecdsa

79. Sử dụng

pip install ecdsa

70 để tạo bảng này trên máy tính của riêng bạn. Trên Intel Core i7 4790K @ 4.0GHz Tôi đang nhận được hiệu suất sau:

pip install ecdsa

7

Để kiểm tra hiệu suất với

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

42 được tải, hãy sử dụng

pip install ecdsa

72. Trên cùng một máy, tôi nhận được hiệu suất sau với

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

42:

pip install ecdsa

7

(Ngoài ra còn có phiên bản

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

43, thực hiện nó bằng

pip install ecdsa

75)

Để so sánh, một triển khai tối ưu hóa cao (bao gồm cả lắp ráp đặc trưng cho đường cong cho một số đường cong), như trong OpenSSL 1.1.1D, cung cấp các số hiệu suất sau trên cùng một máy. Chạy

pip install ecdsa

76 và

pip install ecdsa

77 để tái tạo nó:

pip install ecdsa

7

Chìa khóa và chữ ký có thể được tuần tự hóa theo những cách khác nhau (xem cách sử dụng, bên dưới). Đối với khóa NIST192P, ba biểu diễn cơ bản yêu cầu các chuỗi có độ dài sau (tính bằng byte):

pip install ecdsa

8

Lịch sử

Năm 2006, Peter Pearson đã công bố triển khai ECDSA thuần túy của mình trong một thông điệp tới Sci.crypt, có sẵn từ trang web tải xuống của mình. Vào năm 2010, Brian Warner đã viết một trình bao bọc xung quanh mã này, để làm cho việc sử dụng dễ dàng và an toàn hơn một chút. Vào năm 2020, Hubert Kario đã bao gồm việc triển khai mật mã đường cong elip sử dụng tọa độ Jacobian trong nội bộ, cải thiện hiệu suất khoảng 20 lần. Bạn đang nhìn vào readme cho trình bao bọc này.

Kiểm tra

Để chạy bộ thử nghiệm đầy đủ, hãy làm điều này:

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

0

Trên Intel Core i7 4790K @ 4.0GHz, các thử nghiệm mất khoảng 18 giây để thực hiện. Bộ thử nghiệm sử dụng

pip install ecdsa

78 vì vậy có một số biến đổi vốn có trong thời gian thực hiện bộ thử nghiệm.

Một phần của

pip install ecdsa

79 và

pip install ecdsa

70 kiểm tra khả năng tương thích với OpenSSL, bằng cách chạy công cụ CLI "openSSL", hãy đảm bảo rằng nó có trong

import random
import string
import sys
import ecdsa
import hashlib
import binascii

# randomly generate secret and public keys
sk = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)
pk = sk.get_verifying_key()

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p)

print("public key:", binascii.hexlify(pk.to_string()))
print("public key:", binascii.hexlify(publicKeyVerifyObject.to_string()))

# a message to sign
name = "lastpeony"

# signature of the message
signature = sk.sign(name.encode('utf-8'))


#first test
try:
    print (publicKeyVerifyObject.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False) 


#second test
try:
    print (pk.verify(signature, name.encode('utf-8')))
except ecdsa.BadSignatureError:
    print (False)

46 của bạn nếu bạn muốn kiểm tra khả năng tương thích với nó (nếu OpenSSL bị thiếu, hoặc không hỗ trợ tất cả Các đường cong được hỗ trợ trong các bản phát hành ngược dòng, bạn sẽ thấy các bài kiểm tra bị bỏ qua trong lần chạy

pip install ecdsa

72 trên).

Bảo vệ

Thư viện này không được thiết kế với bảo mật trong tâm trí. Nếu bạn đang xử lý dữ liệu cần được bảo vệ, chúng tôi khuyên bạn nên sử dụng trình bao bọc chất lượng xung quanh OpenSSL. PYCA/Cryptography là một ví dụ về một trình bao bọc như vậy. Trường hợp sử dụng chính của thư viện này là một thư viện di động để kiểm tra khả năng tương tác và là một công cụ giảng dạy.

Thư viện này không bảo vệ chống lại các cuộc tấn công kênh phụ.

Không cho phép kẻ tấn công đo thời gian bạn mất bao lâu để tạo một cặp khóa hoặc ký một tin nhắn. Không cho phép những kẻ tấn công chạy mã trên cùng một máy vật lý khi việc tạo hoặc ký cặp khóa đang diễn ra (điều này bao gồm các máy ảo). Không cho phép kẻ tấn công đo lường mức độ năng lượng mà máy tính của bạn sử dụng trong khi tạo cặp khóa hoặc ký tin nhắn. Không cho phép kẻ tấn công đo nhiễu RF đến từ máy tính của bạn trong khi tạo một cặp khóa hoặc ký tin nhắn. LƯU Ý: Chỉ cần tải khóa riêng sẽ gây ra việc tạo cặp khóa. Các hoạt động hoặc vectơ tấn công khác cũng có thể dễ bị tấn công. Đối với một kẻ tấn công tinh vi quan sát chỉ một hoạt động với khóa riêng sẽ đủ để xây dựng lại hoàn toàn khóa riêng.For a sophisticated attacker observing just one operation with a private key will be sufficient to completely reconstruct the private key.For a sophisticated attacker observing just one operation with a private key will be sufficient to completely reconstruct the private key.

Cũng xin lưu ý rằng bất kỳ thư viện mật mã Pure-Python nào cũng dễ bị tổn thương trước các cuộc tấn công kênh phụ. Điều này là do Python không cung cấp các nguyên thủy an toàn kênh bên (ngoại trừ

pip install ecdsa

73), làm cho lập trình bảo mật kênh bên không thể.

Thư viện này phụ thuộc vào một nguồn số ngẫu nhiên mạnh mẽ. Không sử dụng nó trên một hệ thống trong đó

pip install ecdsa

74 không cung cấp các số ngẫu nhiên an toàn về mặt mật mã.

Cách sử dụng

Bạn bắt đầu bằng cách tạo

pip install ecdsa

75. Bạn có thể sử dụng điều này để ký dữ liệu, bằng cách truyền dữ liệu dưới dạng chuỗi byte và lấy lại chữ ký (cũng là chuỗi byte). Bạn cũng có thể yêu cầu

pip install ecdsa

75 cung cấp cho bạn

pip install ecdsa

77 tương ứng.

pip install ecdsa

77 có thể được sử dụng để xác minh chữ ký, bằng cách truyền cả chuỗi dữ liệu và chuỗi byte chữ ký: nó trả về true hoặc tăng

pip install ecdsa

79.

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

1

Mỗi ________ 85/________ 87 được liên kết với một đường cong cụ thể, như NIST192P (cái mặc định). Các đường cong dài hơn an toàn hơn, nhưng mất nhiều thời gian hơn để sử dụng, và dẫn đến các phím và chữ ký dài hơn.

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

2

pip install ecdsa

75 có thể được tuần tự hóa thành một số định dạng khác nhau: ngắn nhất là gọi

pip install ecdsa

83, sau đó tạo lại nó với

pip install ecdsa

84. Hình thức ngắn này không ghi lại đường cong, vì vậy bạn phải chắc chắn chuyển sang

pip install ecdsa

85 cùng một đường cong bạn đã sử dụng cho khóa ban đầu. Hình thức ngắn của khóa ký dựa trên NIST192P chỉ dài 24 byte. Nếu mã hóa điểm không hợp lệ hoặc nó không nằm trên đường cong được chỉ định,

pip install ecdsa

85 sẽ tăng

pip install ecdsa

87.

pip install ecdsa

03

Lưu ý: Mặc dù các phương thức được gọi là

pip install ecdsa

88, loại chúng trả về thực sự là

pip install ecdsa

89, phần "chuỗi" còn sót lại từ Python 2.

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

00 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

01 sẽ tuần tự hóa khóa ký vào cùng các định dạng mà OpenSSL sử dụng. Tệp PEM trông giống như định dạng được mã hóa

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

02 được mã hóa ____102 và định dạng DER là một dạng nhị phân ngắn hơn của cùng một dữ liệu.

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

03 sẽ hoàn tác tuần tự hóa này. Các định dạng này bao gồm tên đường cong, vì vậy bạn không cần phải chuyển trong một mã định danh đường cong cho máy khử trùng. Trong trường hợp tệp bị dị tật

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

04 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

05 sẽ tăng

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

06 hoặc ____107.

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

4

Tương tự như vậy,

pip install ecdsa

77 có thể được tuần tự hóa theo cùng một cách:

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

09,

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

10 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

11. Đối số

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

12 tương tự là cần thiết cho

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

13.

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

5

Có một vài cách khác nhau để tính toán một chữ ký. Về cơ bản, ECDSA lấy một số đại diện cho dữ liệu được ký và trả về một cặp số đại diện cho chữ ký. Đối số

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

14 đối với

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

15 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

16 được sử dụng để biến một chuỗi tùy ý thành một tiêu hóa có độ dài cố định, sau đó được biến thành một số mà ECDSA có thể ký, và cả dấu và xác minh phải sử dụng cùng một cách tiếp cận. Giá trị mặc định là

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

17, nhưng nếu bạn sử dụng NIST256P hoặc đường cong dài hơn, bạn có thể sử dụng

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

18 thay thế.

Ngoài ra còn có nhiều cách để đại diện cho một chữ ký. Các phương thức

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

15 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

16 mặc định trình bày nó như một chuỗi ngắn, cho tính đơn giản và chi phí tối thiểu. Để sử dụng một sơ đồ khác, hãy sử dụng các đối số

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

21 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

22. Có các chức năng trợ giúp trong mô -đun

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

23 có thể hữu ích ở đây.

Cũng có thể tạo ra một

pip install ecdsa

75 từ một "hạt giống", có tính xác định. Điều này có thể được sử dụng trong các giao thức nơi bạn muốn lấy các khóa ký hợp nhất từ một số bí mật khác, ví dụ khi bạn muốn có ba khóa riêng biệt và chỉ muốn lưu trữ một bí mật chính. Bạn nên bắt đầu với một hạt giống không đáng kể được phân phối đồng đều với khoảng

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

25 byte entropy, sau đó sử dụng một trong các chức năng của người trợ giúp trong

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

23 để chuyển đổi nó thành một số nguyên trong phạm vi chính xác, và cuối cùng chuyển nó thành

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

27, như thế này: như thế này:

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

6

Trong trường hợp ứng dụng sẽ xác minh rất nhiều chữ ký được tạo bằng một khóa duy nhất, có thể tính toán trước một số giá trị bên trong để xác minh chữ ký nhanh hơn đáng kể. Điểm hòa vốn xảy ra ở khoảng 100 chữ ký được xác minh.

Để thực hiện điều chỉnh, bạn có thể gọi phương thức

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

28 theo phiên bản

pip install ecdsa

77:

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

7

Khi

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

28 được gọi, tất cả các xác minh chữ ký với khóa này sẽ nhanh hơn để thực hiện.

Khả năng tương thích OpenSSL

Để tạo ra các chữ ký có thể được xác minh bằng các công cụ OpenSSL hoặc để xác minh các chữ ký được tạo ra bởi các công cụ đó, sử dụng:

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

8

LƯU Ý: Nếu khả năng tương thích với OpenSSL 1.0.0 hoặc sớm hơn là cần thiết, có thể sử dụng

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

31 và

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

32 từ

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

23 để viết và đọc chữ ký tương ứng.

Các khóa cũng có thể được viết theo định dạng mà OpenSSL có thể xử lý:

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

9

Sự hỗn loạn

Tạo khóa ký với

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

34 yêu cầu một số hình thức entropy (trái ngược với ____ 135/________ 136/________ 137/________ 138, có tính xác định và không yêu cầu nguồn entropy). Nguồn mặc định là

pip install ecdsa

74, nhưng bạn có thể vượt qua bất kỳ chức năng nào khác hoạt động như

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

40 dưới dạng đối số

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

41 để làm điều gì đó khác biệt. Điều này có thể hữu ích trong các bài kiểm tra đơn vị, nơi bạn muốn đạt được kết quả lặp lại. Tiện ích

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

42 rất tiện dụng ở đây: nó lấy hạt giống và tạo ra một luồng giả ngẫu nhiên mạnh mẽ từ nó:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

0

Tương tự như vậy, việc tạo chữ ký ECDSA yêu cầu một số ngẫu nhiên và mỗi chữ ký phải sử dụng một số khác nhau (sử dụng cùng một số hai lần sẽ ngay lập tức tiết lộ khóa ký riêng). Phương pháp

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

15 có một đối số

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

41 hoạt động giống như

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

45.

Chữ ký xác định

Nếu bạn gọi

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

46 thay vì

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

47, mã sẽ tạo ra một chữ ký xác định thay vì ngẫu nhiên. Điều này sử dụng thuật toán từ RFC6979 để tạo ra giá trị

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

48 duy nhất, xuất phát từ khóa riêng và thông báo được ký. Mỗi lần bạn ký cùng một tin nhắn với cùng một khóa, bạn sẽ nhận được cùng một chữ ký (sử dụng cùng một

publicKeyVerifyObject = ecdsa.VerifyingKey.from_string(bytes.fromhex(binascii.hexlify(pk.to_string()).decode('utf-8')), curve=ecdsa.NIST256p, hashfunc = hashlib.sha256)

48).

Điều này có thể trở thành mặc định trong một phiên bản trong tương lai, vì nó không dễ bị lỗi của nguồn entropy.

Ví dụ

Tạo một cặp khóa NIST192P và ngay lập tức lưu cả hai vào đĩa:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

1

Tải khóa ký từ đĩa, sử dụng nó để ký tin nhắn (sử dụng SHA-1) và viết chữ ký vào đĩa:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

2

Tải khóa xác minh, tin nhắn và chữ ký từ đĩa và xác minh chữ ký (giả sử băm SHA-1):

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

3

Tạo một cặp khóa NIST521P:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

4

Tạo ba khóa ký độc lập từ hạt giống chính:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

5

Tải một khóa xác minh từ đĩa và in nó bằng mã hóa HEX ở định dạng không nén và nén (được xác định trong các tiêu chuẩn x9.62 và Sec1):

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

6

Tải một khóa xác minh từ chuỗi hex từ định dạng nén, đầu ra không nén:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

7

Trao đổi khóa ECDH với bên từ xa:

public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
public key: b'659ee7dcc3905b7be2969ec1c09824d81d85f54202865eeee3e5a950f585d092b90727759bded7caad24825a501e6e4bf2cb05726d9a153de7a3cc3a58ccc7c7'
True
True

8

programming python Python secp256k1 Ecdsa Python Secp256k1 Python example Install secp256k1 ECDH Python Python ecdsa github Python ECDSA docs Ecdsa Ubuntu

Hướng dẫn ecdsa secp256k1 python - trăn ecdsa secp256k1

Pure-Python ECDSA và ECDH

Đặc trưng

Phụ thuộc

Cài đặt

Tốc độ, vận tốc

Lịch sử

Kiểm tra

Bảo vệ

Cách sử dụng

Khả năng tương thích OpenSSL

Sự hỗn loạn

Chữ ký xác định

Ví dụ

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội