สร้างรหัสผ่านที่แข็งแกร่งและจำง่ายโดยใช้การเข้ารหัสแบบคลาสสิกหรือไม่

รหัสผ่านอาจจำยาก ตัวอย่างเช่น:

H7535637353959595*9608J614625C1313^398583I0397897j^

Bob จึงต้องการสร้างและใช้รหัสผ่านที่ดีสำหรับ GPG ที่เขาไม่ต้องจำ เขาจะไม่ค่อยใช้รหัสผ่านนี้ (การเข้ารหัสแบบอสมมาตรสำหรับการจัดเก็บแบบออฟไลน์) เมื่อเขาต้องการรหัสผ่าน เขาจะสร้างรหัสผ่านด้วยดินสอและกระดาษจากข้อมูลสำคัญบางอย่างที่เก็บไว้ในที่เดียว: หัวของเขา

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

ที่สำคัญเขาต้องการหลีกเลี่ยง "ความปลอดภัย" ผ่านการทำให้งงงวย

ลักษณะและหลักการบางประการที่อยู่เบื้องหลัง รหัส VIC อยู่ในใจ (อยู่แล้ว):

1. ตัวเลข 5 หลัก (สุ่มอย่างแท้จริง)

67106 ขยายเป็น 10 หลัก 67106 + (6+7=3) + (7+1=8) ฯลฯ 6710638169

2. วลีสั้น ๆ ที่จดจำ: ปรัชญาเชิงวิจารณ์ (ใช้อักษร 20 ตัวแรก) ที่เกิดขึ้นใน 5169827304 และ 2159346708

เพื่อให้เรื่องยาวสั้นโดยทำตามกระบวนการของ Bob ซึ่งส่วนใหญ่เหมือนกับรหัส VIC (การเติมลูกโซ่, การสร้างการเรียงสับเปลี่ยนของ 1 ถึง 0, การบวกตัวเลขโดยไม่ถือ) เรามาถึงที่นี่:

    5730481269
    ไม่มี ADIEUS
  3 BCFGHJKLMP
  9 QRTVWXYZ

3. บ๊อบใช้แป้นพิมพ์คร่อมบนวลียาวที่เขาจำได้:

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

เพิ่มพริกไทย ถ้าคุณต้องการ ที่ส่วนท้ายของแถวการเคลื่อนย้าย: *^^ และ 11=A, 22=B ฯลฯ 111=a 222=b ฯลฯ 1111=! 2222=@ ฯลฯ

ผลลัพธ์: H7535637353959595*9608J614625C1313^398583I0397897j^

ด้วยการฝึกฝนเล็กน้อย การจดจำกระบวนการเช่นรหัส VIC ใช้นั้นไม่ใช่เรื่องยาก

คำถาม:

1. วิธีการเช่นนี้สามารถสร้างรหัสผ่านที่รัดกุมพอที่จะใช้ใน GPG ได้หรือไม่

2. วิธีการที่แข็งแกร่งโดยใช้การเข้ารหัสแบบคลาสสิกสำหรับการสร้างรหัสผ่านจะมีลักษณะอย่างไร

หากไม่มีขอบเขตบนของความยาวของรหัสผ่านที่จะใช้ คำแนะนำทั่วไปที่ฉันทราบในการสร้างรหัสผ่านที่รัดกุมและจดจำง่าย (สำหรับคำจำกัดความของคำว่า "ง่าย") คือ เครื่องลูกเต๋า.

แนวคิดพื้นฐานเบื้องหลังคือ เลือกแต่ละคำผ่านการม้วน 5 d6 (เช่น แต่ละคำมี $6^5= 7765= 2^{12.92}\ประมาณ 2^{13}$ ตัวเลือก). รหัสผ่านทั้งหมดคือชุดค่าผสมของ $k$ คำอิสระให้รหัสผ่านด้วย $\ประมาณ {13k}$ บิตของเอนโทรปี จากนั้นคุณสามารถเลือก $k = 6$ (หรือตัวเลือกอื่นๆ ที่คุณต้องการ) เพื่อรับรหัสผ่านด้วย $\ประมาณ 80$ บิตของเอนโทรปี

ฉันเพิ่งสร้างรหัสผ่าน:

ปีประณีตแย่ที่สุดไม่เรียงลำดับแสดงว่าสกิปเปอร์

ฉันสามารถจดจำได้ทันทีหรือไม่ ไม่ ฉันขอสร้างเรื่องใน $\ประมาณ 10$ นาทีเพื่อช่วยในการท่องจำอย่างมากมาย? อาจจะ. นอกจากนี้ยังมีประโยชน์ (มหาศาล) ที่แม้แต่ผู้ใช้ที่ไม่ก้าวหน้าทางเทคโนโลยีก็สามารถจำรหัสผ่านที่สร้างขึ้นได้ นอกจากนี้ยังมีข้อดี (อีกครั้งมาก) ที่เป็นเพียงการเข้ารหัสมาตรฐาน $\ประมาณ 80$ บิตรหัสผ่านโดยใช้รายการคำ (สาธารณะ) เพื่อช่วยเหลือ มนุษย์ การท่องจำ ในทางคณิตศาสตร์ ไม่มีอะไรที่ไม่สำคัญเกิดขึ้นซึ่งอาจถูกโจมตีได้

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

ฉันจะถือว่าผู้ใช้สามารถจำคำหลายคำที่มีความยาวต่างกันได้ เป็นต้น ["ลอนดอน", "อิสตันบูล", "เชฟฟิลด์"].

คุณสามารถใช้รหัส Vigenere กับคีย์หลายตัวได้ เมื่อคุณทำเช่นนี้ คีย์สำหรับการเข้ารหัสจะยาวเท่ากับคำหลักที่ใช้กันน้อยที่สุด จากตัวอย่างคำ เราได้รับ 72 ตัวอักษร

จากนั้นเราเริ่มต้นด้วยสตริง 72 "เอ" อักขระแล้วเข้ารหัสโดยใช้รหัส Vigenere กับคำสำคัญแต่ละคำ

คำสำคัญ: ['ลอนดอน', 'อิสตันบูล', 'เชฟฟิลด์']
ตัวคูณร่วมน้อย: 72
คีย์เริ่มต้น: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
เข้ารหัสด้วยลอนดอน: ลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอนลอนดอน
เข้ารหัสด้วย ISTANBUL: TGGDBOFZVVHNYPHOWFEOAEIYTGGDBOFZVVHNYPHOWFEOAEIYTGGDBOFZVVHNYPHOWFEOAEIY
เข้ารหัสด้วย SHEFFIELD: LNKIGWJKYNORDUPSHIWVEJNGXRJVISKEDZSQQWLTBNIZDWPCYLOHMRXGZAMVCAKGDJJTIITB
ผลลัพธ์สุดท้าย: LNKIGWJKYNORDUPSHIWVEJNGXRJVISKEDZSQQWLTBNIZDWPCYLOHMRXGZAMVCAKGDJJTIITB

นี่คือรหัส Python บางส่วนที่ทำสิ่งนี้

#!/usr/bin/env python3
นำเข้าคณิตศาสตร์
นำเข้าระบบ

ตัวอักษร = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

ไวเจเนียร์ = {}

สำหรับฉัน ตัวอักษรในการแจกแจง(ALPHABET):
    a = รายการ(ตัวอักษร)
    สำหรับ _ ในช่วง (i):
        ก.ต่อท้าย(a.pop(0))
    vigenere[ตัวอักษร] = ก

คำหลัก = [x.upper() สำหรับ x ใน sys.argv[1:]]

พิมพ์ ("คำหลัก:", คำหลัก)

key_len = math.lcm(*[len(x) สำหรับ x ในคีย์เวิร์ด])
พิมพ์("ตัวคูณร่วมน้อย:", key_len)

key = ["A"] * key_len

พิมพ์ ("คีย์เริ่มต้น:", "".join (คีย์))
สำหรับคำหลักในคำหลัก:
    สำหรับฉันในช่วง (key_len):
        key_letter = คีย์เวิร์ด[i % len(คีย์เวิร์ด)]
        ดัชนี = ALPHABET.index (คีย์ [i])
        คีย์[i] = vigenere[key_letter][ดัชนี]
    พิมพ์ (f"เข้ารหัสด้วย {keyword}:", "".join(key))

พิมพ์ ("ผลลัพธ์สุดท้าย:", "".join (คีย์))

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

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

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

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

ดังนั้น TL;DR คุณจะมีรหัสผ่านและตำแหน่งที่ต้องจำเพียง N-เท่า และอย่างอื่นจะเป็นแบบสุ่ม จึงไม่สามารถบังคับได้ในเวลาที่เหมาะสม และปลอดภัยจากการโจมตีจากพจนานุกรม + หากคุณไม่เปิดเผยตำแหน่ง แม้ว่า รหัสผ่านของคุณรั่วไหล (วิศวกรรมสังคมหรือการคัดลอกวางในแชทผิดพลาด) ผู้โจมตียังคงต้องได้รับ "หีบสมบัติ" กุญแจที่ไม่มีรูกุญแจก็เป็นแค่ของไม่มีค่า

และมันเป็นสิ่งที่ดีที่สุดสำหรับการท่องจำ เพราะคุณไม่จำเป็นต้องจำรหัสผ่าน GPG หรือ algo ที่สร้างรหัสผ่านขึ้นมา