อัลกอริธึมการเข้ารหัสแบบสมมาตรเป็นอัลกอริธึมการเข้ารหัสรุ่นก่อนหน้าพร้อมเทคโนโลยีที่สมบูรณ์ ในอัลกอริธึมการเข้ารหัสแบบสมมาตร ผู้ส่งข้อมูลจะประมวลผลข้อความธรรมดา (ข้อมูลต้นฉบับ) และคีย์การเข้ารหัส (mi yue) ร่วมกับอัลกอริธึมการเข้ารหัสพิเศษ เปลี่ยนให้เป็นข้อความไซเฟอร์เท็กซ์ที่เข้ารหัสที่ซับซ้อนแล้วส่งออกไป หลังจากที่ผู้รับได้รับไซเฟอร์เท็กซ์แล้ว หากเขาต้องการถอดรหัสข้อความต้นฉบับ เขาจำเป็นต้องใช้คีย์ที่ใช้ในการเข้ารหัสและอัลกอริธึมผกผันของอัลกอริธึมเดียวกันเพื่อถอดรหัสไซเฟอร์เท็กซ์เพื่อคืนค่าเป็นข้อความธรรมดาที่อ่านได้ ในอัลกอริธึมการเข้ารหัสแบบสมมาตร จะใช้เพียงคีย์เดียวเท่านั้น ทั้งผู้ส่งและผู้รับใช้คีย์นี้เพื่อเข้ารหัสและถอดรหัสข้อมูล ซึ่งกำหนดให้ผู้ถอดรหัสต้องทราบคีย์การเข้ารหัสล่วงหน้า
อัลกอริธึมการเข้ารหัส Java อย่างง่ายคือ:
BASE พูดอย่างเคร่งครัดคือรูปแบบการเข้ารหัส ไม่ใช่อัลกอริธึมการเข้ารหัส
MD (อัลกอริธึมการแยกข้อความ, อัลกอริธึมการแยกข้อความ)
SHA (อัลกอริทึมแฮชที่ปลอดภัย, อัลกอริธึมแฮชที่ปลอดภัย)
HMAC (รหัสตรวจสอบข้อความแฮช, รหัสตรวจสอบข้อความแฮช)
ประเภทที่ 1 ฐาน
Base เป็นหนึ่งในวิธีการเข้ารหัสที่ใช้กันทั่วไปในการส่งรหัส Bit byte บนอินเทอร์เน็ต คุณสามารถดู RFC~RFC ซึ่งมีข้อกำหนดเฉพาะโดยละเอียดสำหรับ MIME การเข้ารหัสฐานสามารถใช้เพื่อถ่ายทอดข้อมูลการระบุตัวตนที่ยาวขึ้นในสภาพแวดล้อม HTTP ตัวอย่างเช่น ในระบบ Java Persistence Hibernate นั้น Base ถูกใช้เพื่อเข้ารหัสตัวระบุเฉพาะแบบยาว (โดยปกติจะเป็น UUID - บิต) ลงในสตริง ซึ่งใช้เป็นพารามิเตอร์ในรูปแบบ HTTP และ HTTP GET URL ในแอปพลิเคชันอื่นๆ มักจำเป็นต้องเข้ารหัสข้อมูลไบนารี่ให้อยู่ในรูปแบบที่เหมาะสมสำหรับการวางตำแหน่งใน URL (รวมถึงฟิลด์แบบฟอร์มที่ซ่อนอยู่) ในขณะนี้ ไม่สามารถอ่านการเข้ารหัสฐานได้ กล่าวคือ ข้อมูลที่เข้ารหัสจะไม่สามารถมองเห็นได้ด้วยตาเปล่าโดยตรง (ที่มา: สารานุกรมไป่ตู้)
รหัสการใช้งานจาวา:
แพ็คเกจ com.cn การเข้ารหัสแบบทางเดียว import sun.misc.BASEDecoder; import sun.misc.BASEEncoder;/*การเข้ารหัสและถอดรหัส BASE เป็นแบบสองทาง และสามารถพบวิธีแก้ปัญหาแบบผกผันได้ ชั้นเรียน แม้ว่าจะสามารถค้นหาและใช้ใน JDK ได้ แต่ก็ไม่พบใน API คลาสที่เริ่มต้นด้วย sun และ com.sun ใน JRE นั้นไม่มีเอกสารเป็นพื้นฐานของไลบรารีคลาส java และ javax การใช้งานส่วนใหญ่เกี่ยวข้องกับแพลตฟอร์มพื้นฐานและโดยทั่วไปไม่แนะนำ พูดอย่างเคร่งครัด BASE คือรูปแบบการเข้ารหัส ในขณะที่อัลกอริธึมที่ไม่เข้ารหัสส่วนใหญ่จะประกอบด้วย BASEEncoder และ BASEDecoder สองคลาส เราเพียงแต่ต้องรู้วิธีใช้วิธีการที่เกี่ยวข้องเท่านั้น นอกจากนี้ จำนวนไบต์ที่สร้างขึ้นหลังจากการเข้ารหัส BASE จะเป็นจำนวนทวีคูณของ . หากจำนวนไบต์ไม่เพียงพอ ให้กรอกด้วยสัญลักษณ์ = BASE ตามคำจำกัดความของ RFC ฐานถูกกำหนดเป็น: การเข้ารหัสการถ่ายโอนเนื้อหาฐานได้รับการออกแบบมาเพื่ออธิบายลำดับของบิตใด ๆ ในรูปแบบที่มนุษย์ไม่สามารถรับรู้โดยตรงได้อย่างง่ายดาย (การเข้ารหัสการถ่ายโอนเนื้อหาพื้นฐานได้รับการออกแบบเพื่อแสดงลำดับอ็อกเท็ตที่กำหนดเองในรูปแบบที่มนุษย์ไม่สามารถอ่านได้) พบได้ทั่วไปในอีเมลและการเข้ารหัส http เมื่อดักข้อมูล http คุณจะพบช่องชื่อผู้ใช้และรหัสผ่านสำหรับการเข้าสู่ระบบ การดำเนินการเข้ารหัสผ่าน BASE */public class BASE { /** * BASE decryption* * @param key * @return * @throws Exception */ public static byte[] decryptBASE(String key) พ่น Exception { return (new BASEDecoder()).decodeBuffer(key) } /** * การเข้ารหัส BASE* * @param key * @return * @throws Exception */ public static String encryptBASE(byte[] key) ส่งข้อยกเว้น { return (new BASEEncoder()).encodeBuffer(key); } สาธารณะคงเป็นโมฆะ main(String[] args) { String result= BASE.encryptBASE(str.getBytes()); out.println("result=====ข้อมูลที่เข้ารหัส=========="+result); byte result[]= BASE.decryptBASE(result); str=new String(result); System.out.println("str========ข้อมูลที่ถอดรหัส========"+str); } catch (ข้อยกเว้น e) { e.printStackTrace( );ประเภทที่สอง นพ
MD คือ Message-Digest Algorithm (อัลกอริธึม Message-Digest) ซึ่งใช้เพื่อให้แน่ใจว่าการส่งข้อมูลมีความสมบูรณ์และสม่ำเสมอ มันเป็นหนึ่งในอัลกอริธึมแฮชที่ใช้กันอย่างแพร่หลายในคอมพิวเตอร์ (แปลว่าอัลกอริธึมการแยกย่อยและอัลกอริธึมแฮช) โดยทั่วไป MD ได้รับการนำไปใช้ในภาษาโปรแกรมกระแสหลัก การคำนวณข้อมูล (เช่น ตัวอักษรจีน) ให้เป็นค่าความยาวคงที่เป็นหลักการพื้นฐานของอัลกอริธึมแฮชรุ่นก่อนหน้าคือ MD, MD และ MD ใช้กันอย่างแพร่หลายในเทคโนโลยีการเข้ารหัสและถอดรหัส ซึ่งมักใช้สำหรับการตรวจสอบไฟล์ ตรวจสอบ? ไม่ว่าไฟล์จะใหญ่แค่ไหน ก็สามารถสร้างค่า MD ที่ไม่ซ้ำกันได้หลังจาก MD ตัวอย่างเช่น การสอบเทียบ ISO ในปัจจุบันคือการสอบเทียบ MD วิธีการใช้งาน? แน่นอนว่าค่า MD จะถูกสร้างขึ้นหลังจากส่งผ่าน ISO ผ่าน MD โดยทั่วไปแล้ว เพื่อนที่ดาวน์โหลด linux-ISO จะเห็นสตริง MD ถัดจากลิงก์ดาวน์โหลด มันถูกใช้เพื่อตรวจสอบว่าไฟล์สอดคล้องกันหรือไม่
การใช้งานจาวา:
แพ็คเกจ com.cn การเข้ารหัสแบบทางเดียว import java.math.BigInteger; import java.security.MessageDigest;/*MD (อัลกอริธึม Message Digest, อัลกอริธึมการแยกข้อความ) โดยปกติแล้วเราจะไม่ใช้การเข้ารหัส MD ข้างต้นโดยตรง โดยปกติแล้วอาร์เรย์ไบต์ที่สร้างโดย MD จะถูกส่งไปยัง BASE จากนั้นเข้ารหัสเพื่อรับสตริงที่เกี่ยวข้อง Digest: assembly*/public class MD { public static Final String KEY_MD = "MD" public static String getResult(String inputStr) { System .out.println("========ข้อมูลก่อนการเข้ารหัส:"+inputStr); BigInteger bigInteger=null; ลอง { MessageDigest md = MessageDigest.getInstance(KEY_MD); ไบต์[] inputData = inputStr.getBytes(); md.update(inputData); bigInteger = new BigInteger(md.digest() } catch (ข้อยกเว้น e) {e.printStackTrace(); } System.out.println("หลังจากการเข้ารหัส MD:" + bigInteger.toString()); return bigInteger.toString(); } public static void main(String args[]) { ลอง { String inputStr = "การเข้ารหัสอย่างง่าย"; getResult(inputStr); } catch (ข้อยกเว้น e) { e.printStackTrace();อัลกอริทึม MD มีลักษณะดังต่อไปนี้:
ความสามารถในการบีบอัด: สำหรับข้อมูลที่มีความยาวเท่าใดก็ได้ ความยาวของค่า MD ที่คำนวณได้จะคงที่
, คำนวณง่าย: คำนวณค่า MD จากข้อมูลเดิมได้ง่าย
ความต้านทานต่อการปรับเปลี่ยน: หากมีการเปลี่ยนแปลงใดๆ กับข้อมูลต้นฉบับ แม้ว่าจะมีการแก้ไขเพียงไบต์เดียวก็ตาม ค่า MD ที่ได้จะแตกต่างกันมาก
, การป้องกันการชนกันที่อ่อนแอ: การทราบข้อมูลต้นฉบับและค่า MD ของมัน เป็นเรื่องยากมากที่จะหาข้อมูลที่มีค่า MD เท่ากัน (นั่นคือ ข้อมูลปลอม)
, การป้องกันการชนกันอย่างรุนแรง: เป็นเรื่องยากมากที่จะหาข้อมูลสองข้อมูลที่แตกต่างกันเพื่อให้มีค่า MD เท่ากัน
หน้าที่ของ MD คืออนุญาตให้ "บีบอัด" ข้อมูลความจุสูงให้อยู่ในรูปแบบที่เป็นความลับ (นั่นคือ แปลงสตริงไบต์ที่มีความยาวเท่าใดก็ได้ให้เป็นสตริงที่มีเลขฐานสิบหกตามความยาวที่กำหนด) ก่อนที่จะเซ็นชื่อคีย์ส่วนตัวด้วยดิจิทัล ซอฟต์แวร์ลายเซ็น นอกจาก MD แล้ว ยังมี sha-, RIPEMD และ Haval ที่มีชื่อเสียงอีกด้วย
ประเภทที่สามSHA
อัลกอริทึม Secure Hash ใช้ได้กับ Digital Signature Algorithm DSA ที่กำหนดใน Digital Signature Standard DSS เป็นหลัก สำหรับข้อความที่มีความยาวน้อยกว่า ^ บิต SHA จะสร้างการแยกย่อยข้อความหนึ่งบิต อัลกอริธึมนี้ได้รับการพัฒนาและปรับปรุงโดยผู้เชี่ยวชาญด้านการเข้ารหัสในช่วงหลายปีที่ผ่านมา และได้รับการพัฒนาให้สมบูรณ์แบบและใช้กันอย่างแพร่หลายมากขึ้นเรื่อยๆ แนวคิดของอัลกอริธึมนี้คือการรับข้อความธรรมดาแล้วแปลงเป็นข้อความไซเฟอร์เท็กซ์ (โดยปกติจะเล็กกว่า) ในลักษณะที่ไม่สามารถย้อนกลับได้ นอกจากนี้ยังสามารถเข้าใจได้ง่ายว่าเป็นการรับสตริงโค้ดอินพุต (เรียกว่าการแมปล่วงหน้า) หรือข้อมูล) และกระบวนการแปลงเป็นลำดับเอาต์พุตที่มีตัวเลขคงที่ความยาวสั้น ซึ่งก็คือค่าแฮช (หรือที่เรียกว่าการแยกย่อยข้อความหรือรหัสตรวจสอบความถูกต้องของข้อความ) ค่าฟังก์ชันแฮชสามารถกล่าวได้ว่าเป็น "ลายนิ้วมือ" หรือ "ย่อย" ของข้อความธรรมดา ดังนั้นลายเซ็นดิจิทัลของค่าแฮชจึงถือได้ว่าเป็นลายเซ็นดิจิทัลของข้อความธรรมดา
การใช้งานจาวา:
แพ็คเกจ com.cn การเข้ารหัสทางเดียว นำเข้า java.math.BigInteger; นำเข้า java.security.MessageDigest;/*SHA (อัลกอริทึมแฮชที่ปลอดภัย) ลายเซ็นดิจิทัลและเครื่องมือสำคัญอื่น ๆ ในแอปพลิเคชันการเข้ารหัสถูกนำมาใช้กันอย่างแพร่หลาย มีการใช้กันอย่างแพร่หลายในด้านความปลอดภัยของข้อมูล เช่น อีคอมเมิร์ซ แม้ว่าทั้ง SHA และ MD จะถูกถอดรหัสด้วยวิธีชนกัน แต่ SHA ยังคงเป็นอัลกอริธึมการเข้ารหัสที่ปลอดภัยที่ได้รับการยอมรับ และมีความปลอดภัยมากกว่า MD*/public class SHA { public static Final String KEY_SHA = "SHA" public static String getResult( String inputStr) { BigInteger sha =null; System.out.println("========ข้อมูลก่อนการเข้ารหัส:"+inputStr); byte[] inputData = inputStr.getBytes(); ลอง { MessageDigest messageDigest (KEY_SHA); messageDigest.update(inputData); sha = new BigInteger(messageDigest.println()) sha.toString()); } catch (ข้อยกเว้น e) {e.printStackTrace();} กลับ sha.toString(); } public static void main(String args[]) { ลอง { String inputStr = "การเข้ารหัสอย่างง่าย"; getResult(inputStr); } catch (ข้อยกเว้น e) { e.printStackTrace();SHA-เปรียบเทียบกับ MD
เนื่องจากทั้งคู่ได้มาจาก MD ดังนั้น SHA- และ MD จึงมีความคล้ายคลึงกันมาก ในทำนองเดียวกันจุดแข็งและคุณลักษณะอื่น ๆ ก็คล้ายคลึงกัน แต่มีความแตกต่างหลายประการ:
การรักษาความปลอดภัยจากการโจมตีแบบ Brute Force: ความแตกต่างที่สำคัญและสำคัญที่สุดคือ SHA-Digest นั้นยาวกว่า MD-Digest การใช้เทคนิคการบังคับเดรัจฉาน ความยากในการสร้างข้อความใดๆ ที่มีการแยกย่อยเท่ากับการแยกย่อยข้อความที่กำหนดคือการดำเนินการของลำดับความสำคัญสำหรับ MD และการดำเนินการของลำดับความสำคัญสำหรับ SHA- ด้วยวิธีนี้ SHA- มีความแข็งแกร่งมากขึ้นต่อการโจมตีด้วยกำลังดุร้าย
การรักษาความปลอดภัยต่อการเข้ารหัส: เนื่องจากการออกแบบของ MD ซึ่งมีความเสี่ยงต่อการโจมตีด้วยการเข้ารหัส ทำให้ SHA- ดูมีความเสี่ยงน้อยลงต่อการโจมตีดังกล่าว
ความเร็ว: SHA- ทำงานช้ากว่า MD บนฮาร์ดแวร์เดียวกัน
ประเภทที่สี่HMAC
HMAC (รหัสตรวจสอบความถูกต้องของข้อความแฮช, รหัสตรวจสอบความถูกต้องของข้อความแฮช, โปรโตคอลการตรวจสอบความถูกต้องตามอัลกอริธึมแฮชคีย์ หลักการของรหัสตรวจสอบความถูกต้องของข้อความเพื่อให้ได้การรับรองความถูกต้องคือการใช้ฟังก์ชันสาธารณะและคีย์เพื่อสร้างค่าความยาวคงที่เป็นตัวระบุการรับรองความถูกต้อง ใช้ ระบุความสมบูรณ์ของข้อความ ใช้คีย์เพื่อสร้างบล็อกข้อมูลขนาดเล็กที่มีขนาดคงที่ เช่น MAC และเพิ่มลงในข้อความ จากนั้นส่งโดยใช้คีย์ที่แชร์กับผู้ส่งเพื่อตรวจสอบสิทธิ์
รหัสการใช้งานจาวา:
แพ็คเกจ com.cn การเข้ารหัสทางเดียว / * HMACHMAC (การตรวจสอบข้อความแฮช รหัส รหัสการตรวจสอบความถูกต้องของข้อความแฮช โปรโตคอลการตรวจสอบความถูกต้องตามอัลกอริทึมแฮชของคีย์ หลักการของรหัสการตรวจสอบความถูกต้องของข้อความคือการใช้ฟังก์ชันสาธารณะและคีย์เพื่อสร้างค่าความยาวคงที่เป็นตัวระบุการรับรองความถูกต้อง และใช้ตัวระบุนี้เพื่อตรวจสอบความสมบูรณ์ของ ข้อความ เพศ ใช้คีย์เพื่อสร้างบล็อกข้อมูลขนาดเล็กที่มีขนาดคงที่ ได้แก่ MAC และเพิ่มลงในข้อความแล้วส่งไป javax.crypto .KeyGenerator; นำเข้า javax.crypto.Mac;นำเข้า javax.crypto.SecretKey;นำเข้า javax.crypto.spec.SecretKeySpec;นำเข้า com.cn.comm.Tools;/** * องค์ประกอบการเข้ารหัสพื้นฐาน*/ คลาสนามธรรมสาธารณะ HMAC { สตริงสุดท้ายแบบคงที่สาธารณะ KEY_MAC = "HmacMD"; /** * เริ่มต้นคีย์ HMAC* * @return * @throws ข้อยกเว้น */ สตริงคงที่สาธารณะ initMacKey() ส่งข้อยกเว้น { KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC); SecretKey secretKey = keyGenerator.generateKey(); return BASE.encryptBASE(secretKey.getEncoded()) /** * การเข้ารหัส HMAC: วิธีการหลัก * * @param data * @param key * @return * @throws Exception */ public static String encryptHMAC (byte[] data, String key) ส่งข้อยกเว้น { SecretKey SecretKey = ใหม่ SecretKeySpec(BASE.decryptBASE(คีย์), KEY_MAC); Mac mac = Mac.getInstance(secretKey.getAlgorithm()); mac.init(secretKey); กลับสตริงใหม่ (mac.doFinal(data)); สตริงคงที่ getResult (สตริง inputStr) { เส้นทางสตริง = Tools.getClassPath (); String fileSource=path+"/file/HMAC_key.txt"; System.out.println("========ข้อมูลก่อนการเข้ารหัส:"+inputStr); ลอง { byte[] inputData = inputStr. getBytes(); String key = HMAC.initMacKey(); /*สร้างคีย์*/ System.out.println("Mac key:===" + key); /*เขียนคีย์ไปยังไฟล์*/ Tools.WriteMyFile(fileSource,key); } catch (ข้อยกเว้น e) {e.printStackTrace( );} return result.toString(); } สตริงสาธารณะ getResult (String inputStr) { System.out.println("========ข้อมูลก่อนการเข้ารหัส:"+inputStr); String path=Tools.getClassPath(); String fileSource=path+"/file/HMAC_key.txt"; ;; ลอง { /*Read the key from the file*/ key=Tools.ReadMyFile(fileSource); System.out.println("getResult key:===" + key); (ข้อยกเว้น e) { e.printStackTrace();} String result=null; try { byte[] inputData = inputStr.getBytes(); /*Encrypt data*/ result= HMAC.encryptHMAC(inputData, key .out .println("หลังจากการเข้ารหัส HMAC:===" + result); } catch (ข้อยกเว้น e) {e.printStackTrace();} return result.toString(); } สาธารณะคงเป็นโมฆะ main(String args[]) { ลอง { String inputStr = "การเข้ารหัสอย่างง่าย"; /*ใช้คีย์เดียวกัน: เข้ารหัสข้อมูล: ตรวจสอบว่าผลลัพธ์ของการเข้ารหัสทั้งสองเหมือนกันหรือไม่*/ getResult(inputStr.); } catch (ข้อยกเว้น e) { e.printStackTrace();เนื้อหาข้างต้นเป็นอัลกอริธึมการเข้ารหัสที่หลากหลาย (สี่ประเภท) ที่ใช้กันทั่วไปใน Java ที่บรรณาธิการแบ่งปัน ฉันหวังว่าคุณจะชอบมัน