กุญแจสาธารณะจะตรวจสอบลายเซ็นได้อย่างไร

ฉันพยายามทำให้การจับคีย์สาธารณะ / ส่วนตัวดีขึ้น ฉันเข้าใจว่าผู้ส่งอาจเพิ่มลายเซ็นดิจิทัลลงในเอกสารโดยใช้คีย์ส่วนตัวของเขา / เธอเพื่อรับแฮชของเอกสารเป็นหลัก แต่สิ่งที่ฉันไม่เข้าใจก็คือวิธีที่รหัสสาธารณะสามารถใช้ในการยืนยันลายเซ็นนั้นได้

ความเข้าใจของฉันคือกุญแจสาธารณะเข้ารหัสรหัสส่วนตัวถอดรหัส ... ใครสามารถช่วยฉันเข้าใจบ้าง

ความเข้าใจของคุณเกี่ยวกับ "การเข้ารหัสกุญแจสาธารณะการถอดรหัสคีย์ส่วนตัว" ถูกต้อง ... สำหรับข้อมูล / ข้อความการเข้ารหัส สำหรับลายเซ็นดิจิตอลมันเป็นสิ่งที่ตรงกันข้าม ด้วยลายเซ็นดิจิทัลคุณกำลังพยายามพิสูจน์ว่าเอกสารที่คุณเซ็นชื่อนั้นมาจากคุณ ในการทำเช่นนั้นคุณต้องใช้สิ่งที่มีเพียงคุณเท่านั้น: คีย์ส่วนตัวของคุณ

ลายเซ็นดิจิทัลในคำอธิบายที่ง่ายที่สุดคือแฮช (SHA1, MD5 ฯลฯ ) ของข้อมูล (ไฟล์ข้อความ ฯลฯ ) ซึ่งต่อมาถูกเข้ารหัสด้วยรหัสส่วนตัวของผู้ลงนาม เนื่องจากเป็นสิ่งที่ผู้ลงนามเท่านั้นที่มี (หรือควรมี) นั่นคือที่มาของความเชื่อถือ ทุกคนสามารถเข้าถึง (หรือควรมี) กุญแจสาธารณะของผู้ลงนาม

ดังนั้นเพื่อตรวจสอบลายเซ็นดิจิทัลผู้รับ

1. คำนวณแฮชของข้อมูลเดียวกัน (ไฟล์ข้อความ ฯลฯ )
2. ถอดรหัสลายเซ็นดิจิทัลโดยใช้คีย์สาธารณะของผู้ส่งและ
3. เปรียบเทียบค่าแฮช 2 ค่า

หากตรงกันจะถือว่าลายเซ็นนั้นถูกต้อง หากพวกเขาไม่ตรงกันก็หมายความว่ามีการใช้คีย์ที่แตกต่างกันในการเซ็นชื่อหรือว่าข้อมูลถูกเปลี่ยนแปลง (โดยเจตนาหรือไม่ตั้งใจ)

หวังว่าจะช่วย!

ปุ่มทำงานตรงกันข้าม:

การเข้ารหัสคีย์สาธารณะการถอดรหัสคีย์ส่วนตัว (การเข้ารหัส):

openssl rsautl -encrypt -inkey public.pem -pubin -in message.txt -out message.ssl
openssl rsautl -decrypt -inkey private.pem       -in message.ssl -out message.txt

การเข้ารหัสคีย์ส่วนตัวการถอดรหัสคีย์สาธารณะ (การลงชื่อ):

openssl rsautl -sign -inkey private.pem       -in message.txt -out message.ssl
openssl rsautl       -inkey public.pem -pubin -in message.ssl -out message.txt

opensslด้านล่างนี้เป็นตัวอย่างสคริปต์เพื่อทดสอบการไหลทั้งหมดนี้ด้วย

#!/bin/sh
# Create message to be encrypted
echo "Creating message file"
echo "---------------------"
echo "My secret message" > message.txt
echo "done\n"

# Create asymmetric keypair
echo "Creating asymmetric key pair"
echo "----------------------------"
openssl genrsa -out private.pem 1024
openssl rsa -in private.pem -out public.pem -pubout
echo "done\n"

# Encrypt with public & decrypt with private
echo "Public key encrypts and private key decrypts"
echo "--------------------------------------------"
openssl rsautl -encrypt -inkey public.pem -pubin -in message.txt         -out message_enc_pub.ssl
openssl rsautl -decrypt -inkey private.pem       -in message_enc_pub.ssl -out message_pub.txt
xxd message_enc_pub.ssl # Print the binary contents of the encrypted message
cat message_pub.txt # Print the decrypted message
echo "done\n"

# Encrypt with private & decrypt with public
echo "Private key encrypts and public key decrypts"
echo "--------------------------------------------"
openssl rsautl -sign    -inkey private.pem -in message.txt          -out message_enc_priv.ssl
openssl rsautl -inkey public.pem -pubin    -in message_enc_priv.ssl -out message_priv.txt
xxd message_enc_priv.ssl
cat message_priv.txt
echo "done\n"

สคริปต์นี้แสดงผลต่อไปนี้:

Creating message file
---------------------
done

Creating asymmetric key pair
----------------------------
Generating RSA private key, 1024 bit long modulus
...........++++++
....++++++
e is 65537 (0x10001)
writing RSA key
done

Public key encrypts and private key decrypts
--------------------------------------------
00000000: 31c0 f70d 7ed2 088d 9675 801c fb9b 4f95  1...~....u....O.
00000010: c936 8cd0 0cc4 9159 33c4 9625 d752 5b77  .6.....Y3..%.R[w
00000020: 5bfc 988d 19fe d790 b633 191f 50cf 1bf7  [........3..P...
00000030: 34c0 7788 efa2 4967 848f 99e2 a442 91b9  4.w...Ig.....B..
00000040: 5fc7 6c79 40ea d0bc 6cd4 3c9a 488e 9913  _.ly@...l.<.H...
00000050: 387f f7d6 b8e6 5eba 0771 371c c4f0 8c7f  8.....^..q7.....
00000060: 8c87 39a9 0c4c 22ab 13ed c117 c718 92e6  ..9..L".........
00000070: 3d5b 8534 7187 cc2d 2f94 0743 1fcb d890  =[.4q..-/..C....
My secret message
done

Private key encrypts and public key decrypts
--------------------------------------------
00000000: 6955 cdd0 66e4 3696 76e1 a328 ac67 4ca3  iU..f.6.v..(.gL.
00000010: d6bb 5896 b6fe 68f1 55f1 437a 831c fee9  ..X...h.U.Cz....
00000020: 133a a7e9 005b 3fc5 88f7 5210 cdbb 2cba  .:...[?...R...,.
00000030: 29f1 d52d 3131 a88b 78e5 333e 90cf 3531  )..-11..x.3>..51
00000040: 08c3 3df8 b76e 41f2 a84a c7fb 0c5b c3b2  ..=..nA..J...[..
00000050: 9d3b ed4a b6ad 89bc 9ebc 9154 da48 6f2d  .;.J.......T.Ho-
00000060: 5d8e b686 635f b6a4 8774 a621 5558 7172  ]...c_...t.!UXqr
00000070: fbd3 0c35 df0f 6a16 aa84 f5da 5d5e 5336  ...5..j.....]^S6
My secret message
done

รหัสสาธารณะจะเข้ารหัสและมีเพียงคีย์ส่วนตัวเท่านั้นที่สามารถถอดรหัสได้และรหัสกลับเป็นจริง พวกเขาทั้งสองเข้ารหัสไปยังแฮชที่แตกต่างกัน แต่แต่ละคีย์สามารถถอดรหัสการเข้ารหัสของอีกฝ่ายได้

มีหลายวิธีในการตรวจสอบว่าข้อความมาจากผู้ส่งที่คาดหวัง ตัวอย่างเช่น:

ผู้ส่งส่ง:

1. ข้อความ

2. แฮชของข้อความเข้ารหัสด้วยกุญแจส่วนตัว

ผู้รับ:

3. ถอดรหัสลายเซ็น (2) ด้วยรหัสสาธารณะเพื่อรับข้อความสมมุติว่าเป็นข้อความเดียวกับ (1) แต่เรายังไม่รู้ ตอนนี้เรามีสองข้อความที่เราต้องตรวจสอบเหมือนกัน ดังนั้นเมื่อต้องการทำเช่นนี้เราจะเข้ารหัสพวกเขาทั้งสองด้วยรหัสสาธารณะของเราและเปรียบเทียบสองแฮช ดังนั้นเราจะ ....
4. เข้ารหัสข้อความต้นฉบับ (1) ด้วยรหัสสาธารณะเพื่อรับแฮช
5. เข้ารหัสข้อความถอดรหัส (3) เพื่อรับแฮชที่สองและเปรียบเทียบกับ (4) เพื่อตรวจสอบว่าเหมือนกัน

หากพวกเขาไม่เหมือนกันนั่นหมายถึงข้อความถูกดัดแปลงหรือถูกเซ็นชื่อด้วยกุญแจอื่นและไม่ใช่ที่เราคิดว่า ...

อีกตัวอย่างหนึ่งคือผู้ส่งจะใช้แฮชทั่วไปที่ผู้รับอาจทราบเช่นกัน ตัวอย่างเช่น:

ผู้ส่งส่ง:

1. ข้อความ
2. ใช้แฮชของข้อความที่รู้จักแล้วเข้ารหัสแฮชด้วยคีย์ส่วนตัว

ผู้รับ:

3. ถอดรหัส (2) และรับค่าแฮช
4. แฮชข้อความ (1) ด้วยแฮชเดียวกับที่ผู้ส่งใช้
5. เปรียบเทียบสองแฮชเพื่อให้แน่ใจว่าตรงกัน

สิ่งนี้ทำให้มั่นใจได้ว่าข้อความจะไม่ถูกแก้ไขอีกต่อไปและมาจากผู้ส่งที่คาดหวัง

หากฉันต้องตอบคำถามของคุณอีกครั้งจากวิธีที่ฉันเข้าใจคุณกำลังขอสิ่งต่อไปนี้:

หากการเข้ารหัสของกุญแจสาธารณะทำให้แน่ใจว่าสามารถรับกุญแจสาธารณะจากกุญแจส่วนตัว แต่ไม่สามารถรับกุญแจส่วนตัวจากกุญแจสาธารณะได้คุณอาจสงสัยว่ากุญแจสาธารณะจะถอดรหัสข้อความที่เซ็นชื่อด้วยกุญแจส่วนตัวได้อย่างไรโดยไม่ต้องส่ง เปิดเผยคีย์ส่วนตัวภายในข้อความที่เซ็นชื่อกับผู้รับหรือไม่ (อ่านอีกครั้งสองสามครั้งจนกระทั่งมันสมเหตุสมผล)

คำตอบอื่น ๆ ได้อธิบายแล้วว่าไม่สมมาตรวิธีการเข้ารหัสที่คุณสามารถอย่างใดอย่างหนึ่ง :

1. เข้ารหัสด้วยรหัสสาธารณะถอดรหัสด้วยรหัสส่วนตัวที่ตรงกัน (รหัสเทียมด้านล่าง)

var msg = 'secret message';

var encryptedMessage = encrypt(pub_key, msg);

var decryptedMessage = decrypt(priv_key, encryptedMessage);

print(msg == decryptedMessage == 'secret message'); // True

2. เข้ารหัสด้วยรหัสส่วนตัวถอดรหัสด้วยรหัสสาธารณะที่ตรงกัน (รหัสเทียมด้านล่าง)

var msg = 'secret message';

var encryptedMessage = encrypt(priv_key, msg);

var decryptedMessage = decrypt(pub_key, encryptedMessage); // HOW DOES THIS WORK???

print(msg == decryptedMessage == 'secret message'); // True

เรารู้ว่าทั้งสองตัวอย่าง # 1 และ # 2 ทำงาน ตัวอย่าง # 1 เข้าใจได้ง่ายในขณะที่ตัวอย่าง # 2 ขอให้เป็นคำถามดั้งเดิมคำถามเดิม

กลับกลายเป็นว่าการเข้ารหัสแบบวงรีรูปไข่ (หรือที่เรียกว่า "การคูณแบบวงรีรูปไข่") คือคำตอบของคำถามเดิม การเข้ารหัสแบบโค้งรูปไข่เป็นความสัมพันธ์ทางคณิตศาสตร์ที่ทำให้เกิดเงื่อนไขต่อไปนี้:

1. กุญแจสาธารณะสามารถสร้างทางคณิตศาสตร์จากกุญแจส่วนตัว
2. รหัสส่วนตัวไม่สามารถสร้างได้ทางคณิตศาสตร์จากกุญแจสาธารณะ (เช่น "ฟังก์ชัน trapdoor")
3. คีย์ส่วนตัวสามารถได้รับการยืนยันโดยคีย์สาธารณะ

ส่วนใหญ่เงื่อนไข # 1 และ # 2 สมเหตุสมผล แต่เกี่ยวกับ # 3

คุณมีสองทางเลือกที่นี่:

1. คุณสามารถลงไปในโพรงกระต่ายและใช้เวลาหลายชั่วโมงในการเรียนรู้วิธีการเข้ารหัสรูปไข่แบบวงรี ( นี่คือจุดเริ่มต้นที่ดี ) ... หรือ ...
2. คุณสามารถยอมรับคุณสมบัติข้างต้นได้เช่นเดียวกับที่คุณยอมรับกฎการเคลื่อนที่ 3 ข้อของนิวตันโดยไม่จำเป็นต้องได้รับมาด้วยตนเอง

สรุปเป็น keypair รัฐ / ภาคเอกชนสร้างขึ้นโดยใช้การเข้ารหัสไข่โค้งซึ่งโดยธรรมชาติสร้างสาธารณะและกุญแจส่วนตัวที่ทางคณิตศาสตร์ที่เชื่อมโยงทั้งสองทิศทาง แต่ไม่ได้ในทางคณิตศาสตร์มาได้ทั้งสองทิศทาง นี่คือสิ่งที่ทำให้คุณสามารถใช้กุญแจสาธารณะของใครบางคนในการตรวจสอบว่าพวกเขาเซ็นชื่อข้อความที่ระบุโดยที่พวกเขาไม่เปิดเผยคีย์ส่วนตัวให้คุณ

คิดว่าฉันจะให้คำอธิบายเพิ่มเติมสำหรับทุกคนที่กำลังมองหาบางอย่างที่เปิดเผยอย่างสังหรณ์ใจ

ส่วนใหญ่ของความสับสนนี้เกิดขึ้นจากการตั้งชื่อ 'กุญแจสาธารณะ' และ 'กุญแจส่วนตัว' เช่นนี้เพราะสิ่งเหล่านี้ใช้งานได้จริงโดยตรงกับวิธีการทำความเข้าใจกับ 'กุญแจ'

ใช้การเข้ารหัสเช่น มันอาจจะคิดว่าทำงานเหมือน:

• บุคคลที่ต้องการอ่านข้อความลับแต่ละคนเก็บคีย์ที่ซ่อนอยู่ (เช่นคีย์ส่วนตัว)
• ฝ่ายที่ต้องการส่งข้อความลับทุกคนมีความสามารถในการปลดล็อคที่ถูกล็อค (เช่นการล็อคสาธารณะ)
• จากนั้นการส่งข้อความลับนั้นง่ายพอ ๆ กับการล็อคด้วยการปลดล็อค แต่การปลดล็อคหลังจากนั้นสามารถทำได้ด้วยหนึ่งในกุญแจที่ซ่อนอยู่

วิธีนี้ช่วยให้สามารถส่งข้อความลับระหว่างฝ่ายต่างๆ แต่จากจุดยืนที่เข้าใจง่ายที่นี่ 'ล็อคสาธารณะ' เป็นชื่อที่เหมาะสมกว่า 'กุญแจสาธารณะ'

อย่างไรก็ตามสำหรับการส่งลายเซ็นดิจิทัลบทบาทจะกลับด้าน:

• บุคคลที่ต้องการลงชื่อข้อความเป็นเพียงบุคคลเดียวที่เข้าถึงการล็อคปลดล็อค (เช่นการล็อคส่วนตัว)
• ฝ่ายที่ต้องการตรวจสอบลายเซ็นทั้งหมดมีความสามารถในการรับรหัส (เช่นรหัสสาธารณะ)
• จากนั้นสิ่งที่ผู้ลงนามทำคือสร้างข้อความที่เหมือนกันสองข้อความ: ข้อความที่ทุกคนสามารถอ่านและหนึ่งข้อความที่จะมาพร้อมกับข้อความนั้น

• จากนั้นเมื่อผู้รับได้รับข้อความพวกเขาสามารถอ่านได้จากนั้นใช้กุญแจสาธารณะเพื่อปลดล็อคข้อความที่ล็อคและเปรียบเทียบทั้งสองข้อความ หากข้อความเหมือนกันพวกเขารู้ว่า:

  1. ข้อความที่ปลดล็อคไม่ได้ถูกดัดแปลงในระหว่างการเดินทางและ

  2. ข้อความต้องมาจากบุคคลที่มีการล็อคการจับคู่กับกุญแจสาธารณะของพวกเขา

• และในที่สุดระบบทั้งหมดนี้จะใช้งานได้เฉพาะเมื่อใครก็ตามที่ต้องการตรวจสอบลายเซ็นของผู้ลงนามมีสถานที่ที่เชื่อถือได้เพื่อไปรับกุญแจที่ตรงกันในการล็อคของผู้ลงนาม มิฉะนั้นใคร ๆ ก็สามารถพูดว่า "เฮ้นี่คือกุญแจสำคัญในการล็อคส่วนตัวของผู้อื่น" ส่งข้อความที่แกล้งทำเป็นพวกเขา แต่ล็อคด้วยล็อคส่วนตัวของพวกเขาคุณทำตามขั้นตอนทั้งหมดแล้วและเชื่อว่าข้อความจะต้องเป็นจริง จากคนที่คุณคิด แต่คุณถูกหลอกเพราะคุณเข้าใจผิดว่าเป็นเจ้าของกุญแจสาธารณะที่แท้จริง

ตราบใดที่มีแหล่งข้อมูลที่น่าเชื่อถือสำหรับการเรียกใช้รหัสสาธารณะของผู้ลงนามคุณจะรู้ว่าใครเป็นเจ้าของคีย์สาธารณะที่ถูกต้องและจะสามารถตรวจสอบลายเซ็นของพวกเขาได้

สำหรับคำถามของคุณฉันกำลังดูการใช้ RSA และมีความชัดเจนมากขึ้นเกี่ยวกับวิธีการใช้รหัสสาธารณะเพื่อตรวจสอบลายเซ็นโดยใช้รหัสส่วนตัว ไม่ต้องสงสัยคีย์ส่วนตัวไม่ถูกเปิดเผย นี่คือวิธี ...

เคล็ดลับที่นี่คือการซ่อนรหัสส่วนตัวภายในฟังก์ชั่น ในกรณีนี้,(p-1)*(q-1).

พิจารณาว่า p เป็นคีย์ส่วนตัวและ e เป็นกุญแจสาธารณะ 'p' ถูกห่อหุ้มภายในฟังก์ชั่นอื่นเพื่อให้ซ่อนไว้

E.g., `d = (p-1)(q-1); d * e = 1` (d is the inverse of e - public key)

ข้อมูลที่ส่ง = [เข้ารหัส (แฮช), ข้อความ] = [m ^ d, ข้อความ]; โดยที่ m คือข้อความสมมติว่า 'Data ส่ง' = y เพื่อตรวจสอบความสมบูรณ์ที่เราพบ y ^ e เพื่อรับ m m ^(d*e) = m ^1 = mตั้งแต่

หวังว่านี่จะช่วยได้! :)