DES加解密算法实现

最新推荐文章于 2024-04-13 02:48:39 发布
最新推荐文章于 2024-04-13 02:48:39 发布
阅读量791 收藏 1
点赞数
分类专栏： 网络安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/catchingSun/article/details/52933375
版权

上一篇文章讲了下DES加密算法的原理，这篇文章主要是实现，将之前写的代码贴出来

封装DES加密系统中用到的数据

public class Variable {
	int[] KPArray = { 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10,
			2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39,
			31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29,
			21, 13, 5, 28, 20, 12, 4 };
	int[] LeftMoveTimesArray = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
	int[] CPArray = { 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12,
			4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51,
			45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32 };
	int[] IPArray = { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20,
			12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16,
			8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61,
			53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7 };
	int[] EPArray = { 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10, 11, 12,
			13, 12, 13, 14, 15, 16, 17, 16, 17, 18, 19, 20, 21, 20, 21, 22, 23,
			24, 25, 24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1 };
	int[][][] SBoxArray = {
			{ { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
					{ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
					{ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
					{ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 } },
			{ { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
					{ 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
					{ 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
					{ 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 } },
			{ { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
					{ 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
					{ 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
					{ 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 } },
			{ { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
					{ 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },
					{ 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
					{ 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 } },
			{ { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
					{ 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
					{ 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
					{ 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 } },
			{ { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
					{ 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
					{ 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
					{ 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 } },
			{ { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
					{ 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
					{ 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
					{ 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 } },
			{ { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
					{ 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
					{ 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
					{ 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } } };
	int[] PBoxArray = { 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18,
			31, 10, 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25 };
	int[] FPArray = { 40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63,
			31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
			36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34,
			2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25 };

	/*
	 * Output the rounded ciphertext
	 */
	protected void outputCiphertext(String[] r, String[] l, String ciphertext,
			String ciphertext1, String ciphertext2, int rounds) {
		while (r[rounds].length() < 32) {
			r[rounds] = '0' + r[rounds];
		}
		ciphertext1 = Long.toHexString(Long.parseLong(l[rounds], 2));
		while (ciphertext1.length() < 8) {
			ciphertext1 = '0' + ciphertext1;
		}
		ciphertext2 = Long.toHexString(Long.parseLong(r[rounds], 2));
		while (ciphertext2.length() < 8) {
			ciphertext2 = '0' + ciphertext2;
		}
		ciphertext = ciphertext1 + ciphertext2;
		System.out.println("        " + ciphertext);
	}

	/*
	 * Range Ciphertext or Message according to Initial Permutation (IPArray)
	 */
	protected String rangeTextByInitialPermutation(String text) {
		int ipLength = IPArray.length;
		StringBuilder sc = new StringBuilder();
		for (int i = 0; i < ipLength; i++) {
			sc.append(text.charAt(IPArray[i] - 1));
		}
		return sc.toString();
	}

	/*
	 * science security
	 */
	protected String fFunction(String r, String roundkey) {

		int epLength = EPArray.length;
		int p_BoxLength = PBoxArray.length;
		StringBuilder sc = new StringBuilder();
		StringBuilder sc1 = new StringBuilder();
		String s = "";
		String s1 = "";
		// extend R By Expansion Permutation (EPArray)
		for (int i = 0; i < epLength; i++) {
			sc.append(r.charAt(EPArray[i] - 1));
		}
		s = sc.toString();
		sc.delete(0, sc.length());

		// make the extended r Exclusive-or round key
		String orString = Long.toBinaryString(Long.parseLong(s, 2)
				^ Long.parseLong(roundkey, 2));
		while (orString.length() < 48) {
			orString = '0' + orString;
		}
		String[] s_box = new String[8];

		// Range R according to S-BOX (SBoxArray)
		for (int i = 0; i < 8; i++) {

			if (i != 7) {
				s_box[i] = orString.substring(i * 6, i * 6 + 6);
			} else {
				s_box[i] = "" + orString.substring(i * 6);
			}
			s = "" + s_box[i].charAt(0) + s_box[i].charAt(5);
			s1 = s_box[i].substring(1, 5);
			s_box[i] = Integer.toBinaryString(SBoxArray[i][Integer.parseInt(s,
					2)][Integer.parseInt(s1, 2)]);
			while (s_box[i].length() < 4) {
				s_box[i] = '0' + s_box[i];
			}
			sc1.append(s_box[i]);
		}

		// Range R By according to P-BOX (PBoxArray)
		for (int i = 0; i < p_BoxLength; i++) {
			sc.append(sc1.charAt(PBoxArray[i] - 1));
		}
		return sc.toString();
	}

	/*
	 * Range Ciphertext or Message according to Final Permutation (FPArray)
	 */
	protected String rangeCiphertextOrMessageByFinalPermutation(String text) {
		int fpLength = FPArray.length;
		StringBuilder sc = new StringBuilder();
		for (int i = 0; i < fpLength; i++) {
			sc.append(text.charAt(FPArray[i] - 1));
		}
		System.out.println("        " + sc.toString());
		return sc.toString();
	}

}

生成回合密钥

public class CreateRoundKey {

	Variable va = new Variable();
	int leftMoveTimesArrayLenght = va.LeftMoveTimesArray.length;
	int rounds = 0;
	String[] RoundKey = new String[16];

	/*
	 * check the keyword's parity
	 */
	public String[] checkParity(String keyWord) {
		System.out.println("Create the rounded key:");
		StringBuilder sc = new StringBuilder();
		int count = 0;
		String s = "";
		for (int i = 0; i < keyWord.length(); i++) {
			String s1 = Integer.toBinaryString((int) keyWord.charAt(i));
			while (s1.length() < 8) {
				s1 = '0' + s1;
			}
			s = s + s1;
		}

		while (s.length() < 56) {
			s = '0' + s;
		}
		System.out
				.println("    The keyWord's BinaryString:\n" + "        " + s);
		for (int i = 0; i < s.length(); i++) {
			sc.append(s.charAt(i));
			if (s.charAt(i) == '1') { // get the number of one
				count++;
			}
			if ((i + 1) % 7 == 0) {
				if (count % 2 == 1) {
					sc.append(0);
				} else {
					sc.append(1);
				}
				count = 0;
			}
		}
		System.out.println("    checkParity:\n" + "        " + sc);
		return rangeKeywordByKeyPermutation(sc.toString());
	}

	/*
	 * range the key according to the Key Permutation (KPArray)
	 */
	private String[] rangeKeywordByKeyPermutation(String keyWord) {
		int kpLength = va.KPArray.length;
		StringBuilder sc = new StringBuilder();
		for (int i = 0; i < kpLength; i++) {
			sc.append(keyWord.charAt(va.KPArray[i] - 1));
		}
		System.out.println("    The ranged keyWord:\n" + "        " + sc);
		String kl = sc.toString().substring(0, 28);
		String kr = sc.toString().substring(28);
		System.out.println("    Kl0:\n" + "        " + kl + "\n    Kr0:\n"
				+ "        " + kr);
		return rotateLeft(kl, kr);
	}

	/*
	 * made kl and kr rotate left according to the LeftMoveTimesArray
	 */
	private String[] rotateLeft(String kl, String kr) {
		StringBuilder sckl = new StringBuilder();
		StringBuilder sckr = new StringBuilder();
		System.out.println("    RoundKey:");
		for (int i = 0; i < leftMoveTimesArrayLenght; i++) {
			if (rounds == i) {
				sckl.append(kl.substring(0, va.LeftMoveTimesArray[i]));
				sckr.append(kr.substring(0, va.LeftMoveTimesArray[i]));
				kl = kl.substring(va.LeftMoveTimesArray[i]) + sckl.toString();
				sckl.delete(0, sckl.length());
				kr = kr.substring(va.LeftMoveTimesArray[i]) + sckr.toString();
				sckr.delete(0, sckr.length());
			}
			RoundKey[rounds] = rangeKeywordByCompressionPermutation(kl + kr);
			System.out.println("        "
					+ Long.toHexString(Long.parseLong(RoundKey[rounds], 2)));
			rounds++;
		}
		return RoundKey;
	}

	/*
	 * range keyword according to the Compression Permutation (CPArray)
	 */
	private String rangeKeywordByCompressionPermutation(String keyWord) {
		int cpLength = va.CPArray.length;
		StringBuilder sc = new StringBuilder();
		for (int i = 0; i < cpLength; i++) {
			sc.append(keyWord.charAt(va.CPArray[i] - 1));
		}
		return sc.toString();
	}

}
加密 

public class EncryptionData {

	Variable va = new Variable();
	String[] roundKey = new String[16];
	int rounds = 1;
	String ciphertext = "";

	/*
	 * Get the rounded key
	 */
	public EncryptionData(String[] roundkey) {
		roundKey = roundkey;
		System.out.println("Encrypte the message:");
	}

	/*
	 * Range the message according to Initial Permutation (IPArray)
	 */
	public String rangeMessageByInitialPermutation(String message) {
		String s = "";
		for (int i = 0; i < message.length(); i++) {
			String s1 = Integer.toBinaryString((int) message.charAt(i));
			while (s1.length() < 8) {
				s1 = '0' + s1;
			}
			s = s + s1;
		}
		while (s.length() < 64) {
			s = '0' + s;
		}
		System.out
				.println("    The message's BinaryString:\n" + "        " + s);
		s = va.rangeTextByInitialPermutation(s);

		String[] l = new String[17];
		String[] r = new String[17];

		l[0] = s.toString().substring(0, 32);
		r[0] = s.toString().substring(32);
		System.out.println("    The ranged message:\n" + "        " + s);
		return makeExclusive_or(l, r);
	}

	/*
	 * Do arithmetic on L and R
	 */
	private String makeExclusive_or(String[] l, String[] r) {
		String ciphertext1 = "";
		String ciphertext2 = "";
		System.out.println("    The rounded ciphertext:");
		while (rounds < 17) {

			l[rounds] = r[rounds - 1];
			r[rounds] = Long.toBinaryString(Long.parseLong(l[rounds - 1], 2)
					^ Long.parseLong(
							va.fFunction(r[rounds - 1], roundKey[rounds - 1]),
							2));
			va.outputCiphertext(r, l, ciphertext, ciphertext1, ciphertext2,
					rounds);
			rounds++;
		}
		return va.rangeCiphertextOrMessageByFinalPermutation(r[16] + l[16]);
	}

}
解密 

public class DecryptionData {

	Variable va = new Variable();
	String[] roundKey = new String[16];
	int rounds = 1;
	String ciphertext = "";

	/*
	 * Get the rounded key
	 */
	public DecryptionData(String[] roundkey) {
		roundKey = roundkey;
		System.out.println("Decrypte the message:");
	}

	/*
	 * Range the ciphertext according to Initial Permutation (IPArray)
	 */
	public String rangeCiphertextByInitialPermutation(String ciphertext) {
		String s = "";
		s = ciphertext;
		System.out.println("    The ciphertext's BinaryString:\n" + "        "
				+ s);
		s = va.rangeTextByInitialPermutation(s);

		String[] l = new String[17];
		String[] r = new String[17];

		l[0] = s.toString().substring(0, 32);
		r[0] = s.toString().substring(32);
		System.out.println("    The ranged ciphertext:\n" + "        " + s);
		return makeExclusive_or(l, r);
	}

	/*
	 * Do arithmetic on L and R
	 */
	private String makeExclusive_or(String[] l, String[] r) {
		String ciphertext1 = "";
		String ciphertext2 = "";
		System.out.println("    The rounded message:");
		while (rounds < 17) {
			l[rounds] = r[rounds - 1];
			r[rounds] = Long.toBinaryString(Long.parseLong(l[rounds - 1], 2)
					^ Long.parseLong(va.fFunction(r[rounds - 1],
							roundKey[15 - (rounds - 1)]), 2));
			va.outputCiphertext(r, l, ciphertext, ciphertext1, ciphertext2,
					rounds);
			rounds++;
		}
		return va.rangeCiphertextOrMessageByFinalPermutation(r[16] + l[16]);
	}

}
主函数 

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		@SuppressWarnings("resource")
		Scanner sc = new Scanner(System.in);
		String ciphertext = "", s1 = "", s2 = "", s;
		System.out
				.println("Please input the keyword(the keyword's size should be less than eight):");

		String keyWord = sc.nextLine();
		while (keyWord.length() > 8) {
			System.out
					.println("The keyword's size is more than nine,please input the keyword again:");
			keyWord = sc.nextLine();
		}
		System.out
				.println("Please input the message that will be encrypted(the message's size should be less than nine):");

		String message = sc.nextLine();
		while (message.length() > 8) {
			System.out
					.println("The message's size is more than nine,please input the message again:");
			message = sc.nextLine();
		}
		// Create round key
		String[] roundKey = new String[16];
		CreateRoundKey cr = new CreateRoundKey();
		roundKey = cr.checkParity(keyWord);
		EncryptionData ed = new EncryptionData(roundKey);
		

		// Encrypte
		s = ed.rangeMessageByInitialPermutation(message);
		ciphertext = getCiphertextOrMessage(s, s1, s2, ciphertext);
		System.out.println("    The Ciphertext:\n        " + ciphertext);
		// Decrypte
		DecryptionData dd = new DecryptionData(roundKey);
		s = dd.rangeCiphertextByInitialPermutation(s);
		ciphertext = getCiphertextOrMessage(s, s1, s2, ciphertext);

		System.out.println("    The Message's hesString:\n        "
				+ ciphertext);
		System.out.print("    The Message:\n        ");
		for (int i = 0; i < ciphertext.length(); i += 2) {
			if (i != ciphertext.length() - 3) {
				if (Integer.parseInt(ciphertext.substring(i, i + 2), 16) != 0) {
					System.out.print((char) Integer.parseInt(
							ciphertext.substring(i, i + 2), 16));
				}
			} else {
				if (Integer.parseInt(ciphertext.substring(i), 16) != 0) {
					System.out.print((char) Integer.parseInt(
							ciphertext.substring(i), 16));
				}
			}
		}

	}

	private static String getCiphertextOrMessage(String s, String s1,
			String s2, String ciphertext) {
		s2 = s.substring(32);
		s1 = s.substring(0, 32);
		s1 = Long.toHexString(Long.parseLong(s1, 2));
		while (s1.length() < 8) {
			s1 = '0' + s1;
		}
		s2 = Long.toHexString(Long.parseLong(s2, 2));
		while (s2.length() < 8) {
			s2 = '0' + s2;
		}
		ciphertext = s1 + s2;
		return ciphertext;
	}
}
注意：


catchingSun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 3DES 加解密算法实现源码
06-13
2. 3DES算法说明。密码学中，三重数据加密算法（英语：Triple Data Encryption Algorithm，缩写为TDEA，Triple DEA），或称3DES（Triple DES），是一种对称密钥加密块密码，相当于是对每个数据块应用三次数据加密...
matlab实现DES加密解密算法
12-12
加密为直接输入十六进制的（消息，密钥，1）；解密为（密文，密钥，2）；Index=1为加密，不为1为解密
DES加密算法以及实现
weixin_45929430的博客
10-18 1611
经典的DES加密算法，简单介绍与实现
DES加密与解密原理及C++代码实现
2020
08-17 4万+
一.DES算法简介 DES(Data Encryption Standard)是目前最为流行的加密算法之一。 对称性:DES是对称的，也就是说它使用同一个密钥来加密和解密数据。与此相对的是RSA加密算法,是一种非对称加密算法 分组性:DES还是一种分组加密算法，该算法每次处理固定长度的数据段，称之为分组。DES分组的大小是64位，如果加密的数据长度不是64位的倍数，可以按照某种具体的规则来填...
DES加密解密算法（简单、易懂、超级详细）_des算法，2024年最新作为字节跳动面试官
最新发布
2301_82101171的博客
04-13 2500
在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。需要完整版PDF学习资源私我。
DES 加解密算法的实现
weixin_64251277的博客
01-14 2424
通过本次实验，我掌握了网络端口扫描器的使用方法，熟悉常见端口和其对应的服务程序，可以帮助对系统做出更准确的评估和判断，掌握发现系统漏洞的方法。i++) //将每个分组的8个字符放到数组target中，不够的用空格补充。(i)将 B[J]的第 1 位和第 6 位组合为一个 2 位长度的变量 M，M 作为在 S[J]中的。printf("对不起，您输入的密文不正确，请确认密文的内容，密文的字符数应是16的倍数。(3)、将异或后的结果分为 8 个 6 位长的部分，第 1 位到第 6 位称为 B[1]，第 7。
DES加解密算法原理详解与实现
timerring的博客
07-08 8万+
DES密码编写:要编写DES密码，先熟悉DES原理，其基本流程就是先将明文分成64bit的分组，然后将64bit二进制码输入到密码器中，密码器对输入的64位码首先进行初始置换，然后在64bit主密钥产生的16个子密钥控制下进行16 轮乘积变换，接着再进行逆置换就得到64位已加密的密文。DES的流程图如下：其中DES算法明文分组长为64bit，加密后得到64bit密文，输入初始种子密钥为64bit，第8、16、24、32、40、48、56、64为奇偶校验位，实际的密钥长为56bit。DES加密过程由三个阶段
JavaScript与C 互通的DES加解密算法实现.docx
05-08
JavaScript 与 C# 互通的 DES 加解密算法实现 本文提供了一个使 JavaScript 与 C# 互通的 DES 加解密算法的实现，旨在实现前台页面中使用 JavaScript 版本的 DES 算法将数据加密，传到服务器端，然后使用 C# 版本的...
Java实现DES加解密算法解析
09-01
Java中的DES（Data Encryption Standard）加解密算法是一种基于对称密钥的加密技术，它在信息安全领域中曾经被广泛使用。DES算法的核心是Feistel结构，它将明文分成两半，通过一系列的迭代过程，每个迭代使用不同的...
C语言实现DES加密解密算法
11-11
DES加密解密算法的C语言实现 DES（Data Encryption Standard）是一种对称密钥 BLOCK 加密算法，使用 56 位密钥对 64 位数据块进行加密。下面是 DES 加密解密算法的 C 语言实现的知识点总结。 字节与二进制转换 在...
DES加解密算法 C++实现
11-22
利用C++语言 实现DES加解密 64位明文分组输入，64位密钥。可以直接实现字符串加解密。
DES算法实现加解密的VC++程序
11-23
使用DES算法实现数据块的加解密。实验中输入8个字符作为明文，8个字符作为密钥。加密后，显示出二进制的密文。再解密就可以得到原文。
DES加密算法实现（加解密代码C++）
CH_whale的博客
03-06 1万+
参考博客：加密算法------DES加密算法详解_柯南的博客-CSDN博客_des加密算法 一、算法流程 二、数据定义 数据名称 数据类型 数据描述 ExchangeRules Int[56] 交换规则表 ShiftTable Int[16] 移位表 PC_2 Int[48] .
DES的加密与解密(C语言实现)——大三密码学实验
weixin_58628068的博客
12-06 7174
DES的描述 DES：16轮，Feistel型结构 明文长度：64比特 密钥长度：64比特。实际使用56比特，另8位用作奇偶校验 密文长度：64比特 DES算法用Feistel体制作为框架进行设计，通过实现F函数和密钥扩展函数，并对Feistel进行初始置换和逆初始置换形成DES算法。 DES的加密与解密(C语言实现)——大三密码学实验
DES加密解密算法实现
Levi的博客
01-24 1051
DES加密解密 数据加密标准(Data Encryption Standard, DES)中的算法是第一个也是最重要的现代对称加密算法，其分组长度为64比特，使用的密钥长度为56比特(实际上函数要求一个64位的密钥作为输入，但其中用到的有效长度只有56位，剩余8位可作为奇偶校验位或完全随意设置)，DES加解密过程类似，加解密使用同样的算法，唯一不同的是解密时子密钥的使用次序要反过来。DES的整个体...
Java实现DES加密解密
热门推荐
king的专栏
11-09 9万+
DES(Data Encryption Standard)是一种对称加密算法，所谓对称加密就是加密和解密都是使用同一个密钥。 加密原理： DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行"异或"运算;接着交换这...
DES加密解密算法（简单、易懂、超级详细）
Python栈
01-25 994
1. 通信的双方同时掌握**一个密钥**，加密解密都是由一个密钥完成的（加密密钥等于解密密钥）。2. 双方通信前共同拟定一个密钥，不对第三方公开。3. 不具有个体原子性，一个密钥被共享，泄露几率会大大增加。
数据加密算法--详解DES加密算法原理与实现
weixin_30779691的博客
07-30 5338
DES算法简介 DES(Data Encryption Standard)是目前最为流行的加密算法之一。DES是对称的，也就是说它使用同一个密钥来加密和解密数据。 DES还是一种分组加密算法，该算法每次处理固定长度的数据段，称之为分组。DES分组的大小是64位，如果加密的数据长度不是64位的倍数，可以按照某种具体的规则来填充位。 从本质上来说，DES的安全性依赖于虚假表象，从密码学的术语来讲...
DES加密解密
IT_zkc的博客
02-19 572
package com.imilab.summer.api.app.rn.service.impl; import javax.crypto.Cipher; import javax.crypto.CipherInputStream; import javax.crypto.CipherOutputStream; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import javax.crypto.sp
Java实现与JS相同的Des加解密算法完整实例
10-19
Java实现与JS相同的Des加解密算法完整实例 Java实现与JS相同的Des加解密算法是指使用Java语言和JavaScript语言实现相同的数据加密和解密算法，以确保数据的安全性和可靠性。下面是Java实现与JS相同的Des加解密算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值