java程序实现地排列码加密解密程序：
源程序：
import java.awt.Color。
import java.awt.Dimension。
import java.awt.Toolkit。
import java.awt.event.MouseAdapter。
import java.awt.event.MouseEvent。
import java.io.BufferedWriter。
import java.io.File。
import java.io.FileInputStream。
import java.io.FileNotFoundException。
import java.io.FileOutputStream。
import java.io.FileReader。
import java.io.FileWriter。
import java.io.PrintStream。
import java.util.ArrayList。
import java.util.Random。
import java.util.Scanner。
import javax.swing.JButton。
import javax.swing.JFileChooser。
import javax.swing.JFrame。
import javax.swing.JLabel。
import javax.swing.JOptionPane。
import javax.swing.JPasswordField。
import javax.swing.JTextField。
public class EncryPL
{
private JFrame jfra_Encry。
private JLabel jlab_Sourc。
private JLabel jlab_Dest。
private JLabel jlab_Key。
private JLabel jlab_Err。
private JTextField jtext_Sourc。
private JTextField jtext_Dest。
private JPasswordField jtext_Key。
private JButton jbtn_Encrypt。
private JButton jbtn_UnEncrypt。
private JButton jbtn_Encrypt_Dot。
private JButton jbtn_UnEncrypt_Dot。
private String str_AllCodeFile = "AllCodeFile.txt"。 private String str_SourceFile。
private String str_DestFile。
private String str_KeyText。
private int[][][] AllCode = new int[256][24][4]。
private int[] int_Key = new int[32]。
private byte[] byte_Key = new byte[4]。
private int[] int_KeyStick = new int[32]。
public static void main(String[] args>
{
EncryPL EPL = new EncryPL(>。
EPL.Init_Encry(>。
}
private void Init_Encry(>
{
this.jfra_Encry = new JFrame(>。
this.jfra_Encry.setTitle("排列码加解密">。
this.jfra_Encry.setSize(500, 400>。
Dimension screensize = Toolkit.getDefaultToolkit(>.getScreenSize(>。
this.jfra_Encry.setLocation((screensize.width - this.jfra_Encry.getWidth(>> / 2, (screensize.height - this.jfra_Encry.getHeight(>> / 2>。
this.jfra_Encry.setDefaultCloseOperation(3>。
this.jfra_Encry.setResizable(false>。
this.jfra_Encry.setLayout(null>。
this.jfra_Encry.setVisible(true>。
this.jlab_Sourc = new JLabel(>。
this.jlab_Sourc.setText("源文件:">。
this.jlab_Dest = new JLabel(>。
this.jlab_Dest.setText("终文件:">。
this.jlab_Key = new JLabel(>。
this.jlab_Key.setText("密钥 :">。
this.jlab_Err = new JLabel(>。
this.jlab_Err.setForeground(Color.RED>。
this.jtext_Sourc = new JTextField(>。
this.jtext_Dest = new JTextField(>。
this.jtext_Key = new JPasswordField(>。
this.jbtn_Encrypt = new JButton(>。
this.jbtn_Encrypt.setText("加密">。
this.jbtn_UnEncrypt = new JButton(>。
this.jbtn_UnEncrypt.setText("解密">。
this.jbtn_Encrypt_Dot = new JButton(>。
this.jbtn_Encrypt_Dot.setText("...">。
this.jbtn_UnEncrypt_Dot = new JButton(>。
this.jbtn_UnEncrypt_Dot.setText("...">。
this.jfra_Encry.add(this.jlab_Sourc>。
this.jfra_Encry.add(this.jlab_Dest>。
this.jfra_Encry.add(this.jlab_Key>。
this.jfra_Encry.add(this.jtext_Sourc>。
this.jfra_Encry.add(this.jtext_Dest>。
this.jfra_Encry.add(this.jtext_Key>。
this.jfra_Encry.add(this.jbtn_Encrypt>。
this.jfra_Encry.add(this.jbtn_UnEncrypt>。
this.jfra_Encry.add(this.jbtn_Encrypt_Dot>。
this.jfra_Encry.add(this.jbtn_UnEncrypt_Dot>。
this.jfra_Encry.add(this.jlab_Err>。
this.jlab_Sourc.setBounds(60, 50, 50, 30>。
this.jtext_Sourc.setBounds(110, 50, 270, 30>。
this.jlab_Dest.setBounds(60, 130, 50, 30>。
this.jtext_Dest.setBounds(110, 130, 270, 30>。
this.jlab_Key.setBounds(60, 210, 50, 30>。
this.jtext_Key.setBounds(110, 210, 270, 30>。
this.jbtn_Encrypt.setBounds(160, 290, 80, 30>。
this.jbtn_UnEncrypt.setBounds(280, 290, 80, 30>。
this.jbtn_Encrypt_Dot.setBounds(385, 50, 50, 30>。
this.jbtn_UnEncrypt_Dot.setBounds(385, 130, 50, 30>。
this.jlab_Err.setBounds(220, 30, 150, 20>。
this.jbtn_Encrypt_Dot.addMouseListener(new EncryPL.MouseListener_jframe(this>>。
this.jbtn_UnEncrypt_Dot.addMouseListener(new EncryPL.MouseListener_jframe(this>>。 this.jbtn_Encrypt.addMouseListener(new EncryPL.MouseListener_jframe(this>>。
this.jbtn_UnEncrypt.addMouseListener(new EncryPL.MouseListener_jframe(this>>。
}
private int[] byteToint(byte bt>
{
int[] int_binary = new int[8]。
String str_bt = Integer.toBinaryString(bt>。
int length = str_bt.length(>。
if (length >= 8>
{
str_bt = str_bt.substring(24, 32>。
}
for (int i = 0。 i < 8 - length。 ++i>
{
int_binary[i] = 0。
}
length = str_bt.length(>。
int j = 0。
for (int i = 8 - length。 i < 8。 ++i>
{
int_binary[i] = Integer.valueOf(str_bt.substring(j, j + 1>>.intValue(>。
++j。
}
return int_binary。
}
private byte intTobyte(int[] int_binary>
{
int length = int_binary.length。
byte byte_Zero = 0。
byte[] byte_Num = { -128, 64, 32, 16, 8, 4, 2, 1 }。
for (int i = 0。 i < length。 ++i>
{
if (int_binary[i] != 1>
continue。
byte_Zero = (byte>(byte_Zero + byte_Num[i]>。
}
return byte_Zero。
}
private boolean SaveFile(byte[] byte_FileMess, String str_File> {
int length = byte_FileMess.length。
File file = new File(str_File>。
if (file.exists(>>
{
file.delete(>。
}
try
{
file.createNewFile(>。
FileOutputStream fos_File = new FileOutputStream(file>。 fos_File.write(byte_FileMess>。
fos_File.close(>。
return true。
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("SaveFile 错误">。
}return false。
}
private byte[] ReadFile(String str_File>
{
File file = new File(str_File>。
try
{
FileInputStream fis_File = new FileInputStream(file>。
int length = fis_File.available(>。
byte[] byte_Mess = new byte[length]。
fis_File.read(byte_Mess>。
fis_File.close(>。
return byte_Mess。
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("ReadFile 错误">。
}return null。
}
private void SaveFileBinary(int[] int_FileMess_Mi>
{
StringBuffer str_FileBinary = new StringBuffer(this.str_DestFile>。
int offset = this.str_DestFile.length(> - 4。
str_FileBinary = str_FileBinary.insert(offset, "(Binary>">。
String str_FileBin = str_FileBinary.toString(>。
File file = new File(str_FileBin>。
if (file.exists(>>
{
file.delete(>。
try
{
file.createNewFile(>。
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("SaveFileBinary 错误">。
}
}
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(str_FileBin>>。 int length = int_FileMess_Mi.length。
for (int i = 0。 i < length。 ++i>
{
bw.write(int_FileMess_Mi[i] + " ">。
if ((i + 1> % 100 != 0>
continue。
bw.newLine(>。
bw.flush(>。
}
bw.close(>。
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("SaveFileBinary 错误">。
}
}
private int[] get_path_Code(>
{
int Table_Code = 0。
int Line_Code = 0。
for (int i = 0。 i < 8。 ++i>
{
Table_Code = (int>(Table_Code + this.int_Key[i] * Math.pow(2.0D, 7 - i>>。
Line_Code = (int>(Line_Code + this.int_Key[(8 + i>] * Math.pow(2.0D, 7 - i>>。 }
Line_Code %= 24。
return this.AllCode[Table_Code][Line_Code]。
}
private int[] get_noDoor_Code(int[] path_Code>
{
int[] noDoor_Code = new int[4]。
for (int i = 0。 i < 4。 ++i>
{
int index = 4 * (i + 4> + path_Code[i]。
noDoor_Code[i] = this.int_Key[index]。
}
return noDoor_Code。
}
private int[] Encrypt_intMing(int[] int_MingHalf, int[] path_Code, int[] noDoor_Code> {
int[] int_MiHalf = new int[4]。
for (int i = 0。 i < 4。 ++i>
{
if (noDoor_Code[i] == 0>
{
int index = path_Code[i]。
int_MiHalf[index] = int_MingHalf[i]。
}
else
{
int index = path_Code[i]。
if (int_MingHalf[i] == 0>
{
int_MiHalf[index] = 1。
}
else
{
int_MiHalf[index] = 0。
}
}
}
return int_MiHalf。
}
private int[] UnEncrypt_intMi(int[] int_MiHalf, int[] path_Code, int[] noDoor_Code> {
int[] int_MingHalf = new int[4]。
for (int i = 0。 i < 4。 ++i>
{
if (noDoor_Code[i] == 0>
{
int index = path_Code[i]。
int_MingHalf[i] = int_MiHalf[index]。
}
else
{
int index = path_Code[i]。
if (int_MiHalf[index] == 0>
{
int_MingHalf[i] = 1。
}
else
{
int_MingHalf[i] = 0。
}
}
}
return int_MingHalf。
}
private void ChangeKey(int[] int_MingHalf_ChangeKey>
{
for (int i = 0。 i < 28。 ++i>
{
this.int_KeyStick[i] = this.int_KeyStick[(i + 4>]。
}
for (int i = 0。 i < 4。 ++i>
{
this.int_KeyStick[(i + 28>] = int_MingHalf_ChangeKey[i]。
}
int Local = 0。
int Next = 1。
int Sum = 0。
for (int i = 31。 i >= 0。 --i>
{
Sum = this.int_Key[i] + this.int_KeyStick[i] + Next。 if (Sum == 0>
{
Local = 0。
Next = 0。
}
else if (Sum == 1>
{
Local = 1。
Next = 0。
}
else if (Sum == 2>
{
Local = 0。
Next = 1。
}
else
{
Local = 1。
Next = 1。
}
this.int_Key[i] = Local。
}
int[] int_KeyEight = new int[8]。
for (int i = 0。 i < 8。 ++i>
{
int_KeyEight[i] = this.int_Key[i]。
}
for (int i = 0。 i < 24。 ++i>
{
this.int_Key[i] = this.int_Key[(8 + i>]。
}
for (int i = 0。 i < 8。 ++i>
{
this.int_Key[(24 + i>] = int_KeyEight[i]。
}
}
private byte[] EncryptFile_Do(byte[] byte_FileMess>
{
int byte_FileMess_length = byte_FileMess.length。
int[] int_FileMess_Mi = new int[byte_FileMess_length * 8]。
int[] path_Code = new int[4]。
int[] noDoor_Code = new int[4]。
path_Code = get_path_Code(>。
noDoor_Code = get_noDoor_Code(path_Code>。
byte byte_Ming = byte_FileMess[0]。
int[] int_Ming = byteToint(byte_Ming>。
int[] int_MingUp = new int[4]。
int[] int_MingDown = new int[4]。
for (int i = 0。 i < 4。 ++i>
{
int_MingUp[i] = int_Ming[i]。
int_MingDown[i] = int_Ming[(4 + i>]。
}
int[] int_MingHalf_ChangeKey = new int[4]。
for (int i = 0。 i < 4。 ++i>
{
int_MingHalf_ChangeKey[i] = int_MingUp[i]。
}
int_MingUp = Encrypt_intMing(int_MingUp, path_Code, noDoor_Code>。
for (int i = 0。 i < 4。 ++i>
{
int_FileMess_Mi[i] = int_MingUp[i]。
}
ChangeKey(int_MingHalf_ChangeKey>。
path_Code = get_path_Code(>。
noDoor_Code = get_noDoor_Code(path_Code>。
for (int i = 0。 i < 4。 ++i>
{
int_MingHalf_ChangeKey[i] = int_MingDown[i]。
}
int_MingDown = Encrypt_intMing(int_MingDown, path_Code, noDoor_Code>。 for (int i = 0。 i < 4。 ++i>
{
int_FileMess_Mi[(i + 4>] = int_MingDown[i]。
}
for (int i = 0。 i < 4。 ++i>
{
int_Ming[i] = int_MingUp[i]。
int_Ming[(i + 4>] = int_MingDown[i]。
}
byte_FileMess[0] = intTobyte(int_Ming>。
for (int i = 1。 i < byte_FileMess.length。 ++i>
{
byte_Ming = byte_FileMess[i]。
int_Ming = byteToint(byte_Ming>。
int_MingUp = new int[4]。
int_MingDown = new int[4]。
for (int j = 0。 j < 4。 ++j>
{
int_MingUp[j] = int_Ming[j]。
int_MingDown[j] = int_Ming[(4 + j>]。
}
for (int j = 0。 j < 4。 ++j>
{
int_MingHalf_ChangeKey[j] = int_MingUp[j]。
}
int_MingUp = Encrypt_intMing(int_MingUp, path_Code, noDoor_Code>。
for (int j = 0。 j < 4。 ++j>
{
int_FileMess_Mi[(8 * i + j>] = int_MingUp[j]。
}
ChangeKey(int_MingHalf_ChangeKey>。
path_Code = get_path_Code(>。
noDoor_Code = get_noDoor_Code(path_Code>。
for (int j = 0。 j < 4。 ++j>
{
int_MingHalf_ChangeKey[j] = int_MingDown[j]。
}
int_MingDown = Encrypt_intMing(int_MingDown, path_Code, noDoor_Code>。 for (int j = 0。 j < 4。 ++j>
{
int_FileMess_Mi[(8 * i + 4 + j>] = int_MingDown[j]。
}
for (int j = 0。 j < 4。 ++j>
{
int_Ming[j] = int_MingUp[j]。
int_Ming[(j + 4>] = int_MingDown[j]。
}
byte_FileMess[i] = intTobyte(int_Ming>。
}
SaveFileBinary(int_FileMess_Mi>。
return byte_FileMess。
}
private byte[] UnEncryptFile_Do(byte[] byte_FileMess>
{
int[] path_Code = new int[4]。
int[] noDoor_Code = new int[4]。
path_Code = get_path_Code(>。
noDoor_Code = get_noDoor_Code(path_Code>。
byte byte_Mi = byte_FileMess[0]。
int[] int_Mi = byteToint(byte_Mi>。
int[] int_MiUp = new int[4]。
int[] int_MiDown = new int[4]。
for (int i = 0。 i < 4。 ++i>
{
int_MiUp[i] = int_Mi[i]。
int_MiDown[i] = int_Mi[(4 + i>]。
}
int[] int_MiHalf_ChangeKey = new int[4]。
int_MiUp = UnEncrypt_intMi(int_MiUp, path_Code, noDoor_Code>。
for (int i = 0。 i < 4。 ++i>
{
int_MiHalf_ChangeKey[i] = int_MiUp[i]。
}
ChangeKey(int_MiHalf_ChangeKey>。
path_Code = get_path_Code(>。
noDoor_Code = get_noDoor_Code(path_Code>。
int_MiDown = UnEncrypt_intMi(int_MiDown, path_Code, noDoor_Code>。 for (int i = 0。 i < 4。 ++i>
{
int_MiHalf_ChangeKey[i] = int_MiDown[i]。
}
for (int i = 0。 i < 4。 ++i>
{
int_Mi[i] = int_MiUp[i]。
int_Mi[(i + 4>] = int_MiDown[i]。
}
byte_FileMess[0] = intTobyte(int_Mi>。
for (int i = 1。 i < byte_FileMess.length。 ++i>
{
byte_Mi = byte_FileMess[i]。
int_Mi = byteToint(byte_Mi>。
int_MiUp = new int[4]。
int_MiDown = new int[4]。
for (int j = 0。 j < 4。 ++j>
{
int_MiUp[j] = int_Mi[j]。
int_MiDown[j] = int_Mi[(4 + j>]。
}
int_MiUp = UnEncrypt_intMi(int_MiUp, path_Code, noDoor_Code>。
for (int j = 0。 j < 4。 ++j>
int_MiHalf_ChangeKey[j] = int_MiUp[j]。
}
ChangeKey(int_MiHalf_ChangeKey>。
path_Code = get_path_Code(>。
noDoor_Code = get_noDoor_Code(path_Code>。
int_MiDown = UnEncrypt_intMi(int_MiDown, path_Code, noDoor_Code>。
for (int j = 0。 j < 4。 ++j>
{
int_MiHalf_ChangeKey[j] = int_MiDown[j]。
}
for (int j = 0。 j < 4。 ++j>
{
int_Mi[j] = int_MiUp[j]。
int_Mi[(j + 4>] = int_MiDown[j]。
}
byte_FileMess[i] = intTobyte(int_Mi>。
}
return byte_FileMess。
}
private void EncryptFile(>
{
if (!DoOrNot(>>
return。
try
{
File file_sourc = new File(this.str_SourceFile>。
FileInputStream fis_sourc = new FileInputStream(file_sourc>。
if (fis_sourc.available(> > 0>
{
getAllCode(>。
SetKey(>。
int length = fis_sourc.available(>。
byte[] byte_FileMess = new byte[length]。
fis_sourc.read(byte_FileMess>。
fis_sourc.close(>。
byte_FileMess = EncryptFile_Do(byte_FileMess>。
if (!SaveFile(byte_FileMess, this.str_DestFile>>
return。
JOptionPane.showMessageDialog(this.jfra_Encry, "文件加密完成", "信息提示", 0>。 this.jtext_Sourc.setText("">。
this.jtext_Dest.setText("">。
this.jtext_Key.setText("">。
}
{
JOptionPane.showMessageDialog(this.jfra_Encry, "源文件为空文件", "信息提示", 0>。 }
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("EncryptFile 错误">。
}
}
private void UnEncryptFile(>
{
if (!DoOrNot(>>
return。
try
{
File file_sourc = new File(this.str_SourceFile>。
FileInputStream fis_sourc = new FileInputStream(file_sourc>。
if (fis_sourc.available(> > 0>
{
getAllCode(>。
SetKey(>。
int length = fis_sourc.available(>。
byte[] byte_FileMess = new byte[length]。
fis_sourc.read(byte_FileMess>。
fis_sourc.close(>。
byte_FileMess = UnEncryptFile_Do(byte_FileMess>。
if (!SaveFile(byte_FileMess, this.str_DestFile>>
return。
JOptionPane.showMessageDialog(this.jfra_Encry, "文件解密完成", "信息提示", 0>。 this.jtext_Sourc.setText("">。
this.jtext_Dest.setText("">。
this.jtext_Key.setText("">。
}
else
{
JOptionPane.showMessageDialog(this.jfra_Encry, "源文件为空文件", "信息提示", 0>。 }
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("UnEncryptFile 错误">。
}
}
private void SetKey(>
{
String str_keytext = new String(this.jtext_Key.getPassword(>>。 byte[] key_less = str_keytext.getBytes(>。
byte[] key_equal = new byte[32]。
int[][] int_Key_mid = new int[4][8]。
int length = key_less.length。
if (length < 32>
{
int num_div = 32 / length。
int num_left = 32 % length。
for (int i = 0。 i < length * num_div。 ++i>
{
key_equal[i] = key_less[(i % length>]。
}
for (int i = 0。 i < num_left。 ++i>
{
key_equal[(length * num_div + i>] = key_less[i]。
}
}
else
{
for (int i = 0。 i < 32。 ++i>
{
key_equal[i] = key_less[i]。
}
}
for (int i = 0。 i < 32。 ++i>
{
switch (key_equal[i] % 2>
{
case 0:
this.int_Key[i] = 0。
break。
default:
this.int_Key[i] = 1。
}
}
for (int i = 0。 i < 4。 ++i>
{
for (int j = 0。 j < 8。 ++j>
{
int_Key_mid[i][j] = this.int_Key[(i * 8 + j>]。
}
}
for (int i = 0。 i < 4。 ++i>
{
this.byte_Key[i] = intTobyte(int_Key_mid[i]>。
}
for (int i = 0。 i < 8。 ++i>
{
int k = i % 2。
for (int j = 0。 j < 4。 ++j>
{
if (k == 0>
{
if (this.int_Key[(i * 4 + j>] == 0>
{
this.int_KeyStick[(i * 4 + j>] = 1。
}
if (this.int_Key[(i * 4 + j>] != 1>
continue。
this.int_KeyStick[(i * 4 + j>] = 0。
}
else
{
if (this.int_Key[(i * 4 + j>] == 0>
{
this.int_KeyStick[(i * 4 + j>] = 0。
}
if (this.int_Key[(i * 4 + j>] != 1>
continue。
this.int_KeyStick[(i * 4 + j>] = 1。
}
}
}
}
private boolean DoOrNot(>
{
File file_sourc = new File(this.str_SourceFile>。
if ((file_sourc.exists(>> && (file_sourc.isFile(>>>
{
File file_dest = new File(this.str_DestFile>。
if (file_dest.exists(>>
{
int option = JOptionPane.showConfirmDialog(this.jfra_Encry, "终文件已存在,是否覆盖？",
"信息提示", 0>。
if (option == 0>
{
if (this.str_KeyText.length(> > 16>
{
JOptionPane.showMessageDialog(this.jfra_Encry, "密钥长度过长,不能超过16个字符", "信息提示", 0>。
this.jtext_Key.grabFocus(>。
return false。
}
return true。
}
return false。
}
if (this.str_KeyText.length(> > 16>
{
JOptionPane.showMessageDialog(this.jfra_Encry, "密钥长度过长,不能超过16个字符", "信息提示", 0>。
this.jtext_Key.grabFocus(>。
return false。
}
return true。
}
JOptionPane.showMessageDialog(this.jfra_Encry, "所要加密地文件不存在", "信息提示", 0>。
return false。
}
private void jbtn_EncryptDot_Do(>
{
JFileChooser chooser = new JFileChooser(>。
int option = chooser.showOpenDialog(this.jfra_Encry>。
if (option != 0>
return。
this.jtext_Sourc.setText(chooser.getSelectedFile(>.getAbsolutePath(>>。
}
private void jbtn_UnEncryptDot_Do(>
{
JFileChooser chooser = new JFileChooser(>。
int option = chooser.showOpenDialog(this.jfra_Encry>。
if (option != 0>
return。
this.jtext_Dest.setText(chooser.getSelectedFile(>.getAbsolutePath(>>。
}
private void jbtn_Encrypt_Do(>
{
if (!this.jtext_Sourc.getText(>.equals("">>
{
if (!this.jtext_Dest.getText(>.equals("">>
{
String str_key = new String(this.jtext_Key.getPassword(>>。
if (!str_key.equals("">>
{
File file = new File(this.str_AllCodeFile>。
if (!file.exists(>>
{
productAllCode(>。
}
else
{
getAllCode(>。
}
this.str_SourceFile = this.jtext_Sourc.getText(>。
this.str_DestFile = this.jtext_Dest.getText(>。
this.str_KeyText = new String(this.jtext_Key.getPassword(>>。 EncryptFile(>。
}
else
{
this.jlab_Err.setText("密钥不能为空">。
this.jtext_Key.grabFocus(>。
}
}
else
{
this.jlab_Err.setText("终文件不能为空">。
this.jtext_Dest.grabFocus(>。
}
}
else
{
this.jlab_Err.setText("源文件不能为空">。
this.jtext_Sourc.grabFocus(>。
}
}
private void jbtn_UnEncrypt_Do(>
{
if (!this.jtext_Sourc.getText(>.equals("">>
{
if (!this.jtext_Dest.getText(>.equals("">>
{
String str_key = new String(this.jtext_Key.getPassword(>>。
if (!str_key.equals("">>
{
File file = new File(this.str_AllCodeFile>。
if (!file.exists(>>
{
JOptionPane.showMessageDialog(this.jfra_Encry, "需要解密地排列码不存在,无法正常解密", "错误信息", 0>。
}
else
{
this.str_SourceFile = this.jtext_Sourc.getText(>。
this.str_DestFile = this.jtext_Dest.getText(>。
this.str_KeyText = new String(this.jtext_Key.getPassword(>>。
getAllCode(>。
UnEncryptFile(>。
}
}
else
{
this.jlab_Err.setText("密钥不能为空">。
this.jtext_Key.grabFocus(>。
}
}
else
{
this.jlab_Err.setText("终文件不能为空">。
this.jtext_Dest.grabFocus(>。
}
}
else
{
this.jlab_Err.setText("源文件不能为空">。
this.jtext_Sourc.grabFocus(>。
}
}
private void productAllCode(>
{
int[][] allcode = {
{ 0, 1, 2, 3 }, { 0, 1, 3, 2 }, { 0, 2, 1, 3 }, { 0, 2, 3, 1 },
{ 0, 3, 1, 2 }, { 0, 3, 2, 1 }, { 1, 0, 2, 3 }, { 1, 0, 3, 2 },
{ 1, 2, 0, 3 }, { 1, 2, 3 }, { 1, 3, 0, 2 }, { 1, 3, 2 },
{ 2, 0, 1, 3 }, { 2, 0, 3, 1 }, { 2, 1, 0, 3 }, { 2, 1, 3 },
{ 2, 3, 0, 1 }, { 2, 3, 1 }, { 3, 0, 1, 2 }, { 3, 0, 2, 1 },
{ 3, 1, 0, 2 }, { 3, 1, 2 }, { 3, 2, 0, 1 }, { 3, 2, 1 } }。
for (int i = 0。 i < 24。 ++i>
{
for (int j = 0。 j < 4。 ++j>
{
this.AllCode[0][i][j] = allcode[i][j]。
}
}
ArrayList selectLine = new ArrayList(24>。
Random rd = new Random(>。
for (int i = 1。 i < 256。 ++i>
{
for (int k = 0。 k < 24。 ++k> {
selectLine.add(Integer.valueOf(k>>。
}
int j = 0。
while (!selectLine.isEmpty(>>
{
int random_num = rd.nextInt(24 - j>。
int Code_i = ((Integer>selectLine.get(random_num>>.intValue(>。
selectLine.remove(random_num>。
this.AllCode[i][j] = allcode[Code_i]。
++j。
}
}
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(this.str_AllCodeFile>>。 for (int i = 0。 i < 256。 ++i>
{
for (int j1 = 0。 j1 < 24。 ++j1>
{
for (int k = 0。 k < 4。 ++k>
{
bw.write(this.AllCode[i][j1][k] + " ">。
}
bw.newLine(>。
bw.flush(>。
}
}
bw.close(>。
File file = new File(this.str_AllCodeFile>。
file.setReadOnly(>。
}
catch (Exception e>
{
e.printStackTrace(>。
System.out.println("ProductAllCode 错误">。
}
}
private void getAllCode(>
{
try
{
Scanner scanner = new Scanner(new FileReader(this.str_AllCodeFile>>。 for (int i = 0。 i < 256。 ++i>
{
for (int j = 0。 j < 24。 ++j>
{
for (int k = 0。 k < 4。 ++k>
{
this.AllCode[i][j][k] = scanner.nextInt(>。
}
}
}
scanner.close(>。
}
catch (FileNotFoundException e>
{
e.printStackTrace(>。
System.out.println("getAllCode 错误">。
}
}
class MouseListener_jframe extends MouseAdapter
{
EncryPL epl = new EncryPL(>。
public MouseListener_jframe(EncryPL epl> {
this.epl = epl。
}
public void mouseClicked(MouseEvent e> {
if (e.getSource(> == this.epl.jbtn_Encrypt_Dot>
{
this.epl.jbtn_EncryptDot_Do(>。
}
else if (e.getSource(> == this.epl.jbtn_UnEncrypt_Dot>
{
简单讲解加密技术 加密技术是最常用的安全保密手段，利用技术手段把重要的数据变为乱码（加密）传送，到达目的地后再用相同或不同的手段还原（解密）。 加密技术包括两个元素：算法和密钥。算法是将普通的信息或者可以理解的信息与一串数字（密钥）结合，产生不可理解的密文的步骤，密钥是用来对数据进行编码和解密的一种算法。在安全保密中，可通过适当的钥加密技术和管理机制来保证网络的信息通信安全。 什么是加密技术呢？加密技术是电子商务采取的主要安全保密措施，是最常用的安全保密手段,利用技术手段把重要的数据变为乱码（加密）传送，到达目的地后再用相同或不同的手段还原（解密）。加密技术包括两个元素：算法和密钥。算法是将普通的文本（或者可以理解的信息）与一窜数字（密钥）的结合，产生不可理解的密文的步骤，密钥是用来对数据进行编码和解码的一种算法。在安全保密中，可通过适当的密钥加密技术和管理机制来保证网络的信息通讯安全。密钥加密技术的密码体制分为对称密钥体制和非对称密钥体制两种。相应地，对数据加密的技术分为两类，即对称加密（私人密钥加密）和非对称加密（公开密钥加密）。对称加密以数据加密标准（DES，Data Enc ryption Standard）算法为典型代表，非对称加密通常以RSA（Rivest Shamir Ad 1eman）算法为代表。对称加密的加密密钥和解密密钥相同，而非对称加密的加密密钥和解密密钥不同，加密密钥可以公开而解密密钥需要保密。 加密技术的种类：对称加密（私人密钥加密），非对称加密（公开密钥加密），单项加密。 对称加密：对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥，即加密密钥也可以用作解密密钥，这种方法在密码学中叫做对称加密算法，对称加密算法使用起来简单快捷，密钥较短，且破译困难，除了数据加密标准（DES），另一个对称密钥加密系统是国际数据加密算法（IDEA），它比DNS的加密性好，而且对计算机功能要求也没有那么高。IDEA加密标准由PGP（Pretty Good Privacy）系统使用。 对称加密的种类:DES(数据加密的标准)使用56位的密钥。AES:高级加密标准。3 DES:三圈加密标准它作为现在加密算法的标准。 非对称加密：即公钥加密，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对
HUNAN UNIVERSITY 程序设计训练——文件加密与解密 报告 学生姓名X X X 学生学号20110102308 专业班级建环308 指导老师何英 2012-07-01至 2012-07-13
一、程序设计目的和要求 (3) 二、程序设计内容 (4) 1、总体设计 (4) 1.1主控选择模块 (4) 1.2加密模块 (4) 1.3解密模块 (4) 2、流程图 (5) 三模块详细说明 (6) 四、测试数据及其结果 (7) 五、课程设计总结 (8) 六、附录 (9) 附录1：参考文献 (9) 附录2：程序源代码 (9)
一、程序设计目的和要求 1、目的：为保证个人数据资料不被他人窃取使用，保护个人隐私及个人文件。设计一个基于c语言的文本文件加密及解密软件，可以方便对文本文件的加密与解密。本设计实现了文本文件的解密及解密，运行软件之后只需输入任意一个文本文件的文件名及后缀名即可对该文本文件进行加密或解密操作。本设计的加密与解密系统，使用了面向各类文件的方法，运用Microsoft Visual C++ 6.0实现具有加密、解密、帮助信息、读取文本文件、显示结果、退出等功能的文件加密与解密系统。 2、要求： （1）从键盘输入要进行加密的一行字符串或者需要加密的文件名。 （2）显示菜单： （3）选择菜单，进行相应的操作。加密方法是设置一加密字符串以及对文件的哪些部分进行加密；加密是将原始文件加密并保存到文件中；解密是将加了密的文件还原并保存到文件中，同时应比较与原始文件的一致性； 3、其他要求 （1）变量、函数命名符合规范。 （2）注释详细：每个变量都要求有注释说明用途；函数有注释说明功能，对参数、返回值也要以注释的形式说明用途；关键的语句段要求有注释解释。
RSA加密算法加密与解密过程解析 1.加密算法概述 加密算法根据内容是否可以还原分为可逆加密和非可逆加密。 可逆加密根据其加密解密是否使用的同一个密钥而可以分为对称加密和非对称加密。 所谓对称加密即是指在加密和解密时使用的是同一个密钥：举个简单的例子，对一个字符串C做简单的加密处理，对于每个字符都和A做异或，形成密文S。 解密的时候再用密文S和密钥A做异或，还原为原来的字符串C。这种加密方式有一个很大的缺点就是不安全，因为一旦加密用的密钥泄露了之后，就可以用这个密钥破解其他所有的密文。 非对称加密在加密和解密过程中使用不同的密钥，即公钥和私钥。公钥用于加密，所有人都可见，私钥用于解密，只有解密者持有。就算在一次加密过程中原文和密文发生泄漏，破解者在知道原文、密文和公钥的情况下无法推理出私钥，很大程度上保证了数据的安全性。 此处，我们介绍一种非常具有代表性的非对称加密算法，RSA加密算法。RSA 算法是1977年发明的，全称是RSA Public Key System，这个Public Key 就是指的公共密钥。 2.密钥的计算获取过程 密钥的计算过程为：首先选择两个质数p和q，令n=p*q。 令k=?(n)=(p?1)(q?1),原理见4的分析 选择任意整数d，保证其与k互质 取整数e，使得[de]k=[1]k。也就是说de=kt+1，t为某一整数。
3.RSA加密算法的使用过程 同样以一个字符串来进行举例，例如要对字符串the art of programming 进行加密，RSA算法会提供两个公钥e和n，其值为两个正整数，解密方持有一个私钥d，然后开始加密解密过程过程。 1. 首先根据一定的规整将字符串转换为正整数z，例如对应为0到36，转化后形成了一个整数序列。 2. 对于每个字符对应的正整数映射值z，计算其加密值M=(N^e)%n. 其中N^e表示N的e次方。 3. 解密方收到密文后开始解密，计算解密后的值为(M^d)%n，可在此得到正整数z。 4. 根据开始设定的公共转化规则，即可将z转化为对应的字符，获得明文。 4.RSA加密算法原理解析 下面分析其内在的数学原理，说到RSA加密算法就不得不说到欧拉定理。 欧拉定理(Euler’s theorem)是欧拉在证明费马小定理的过程中，发现的一个适用性更广的定理。 首先定义一个函数，叫做欧拉Phi函数，即?(n)，其中，n是一个正整数。?(n)=总数(从1到n?1，与n互质整数) 比如5，那么1，2，3，4，都与5互质。与5互质的数有4个。?(5)=4再比如6，与1，5互质，与2，3，4并不互质。因此，?(6)=2
重庆交通大学实验报告 班级：计信专业2012级2班 学号： 631206060232 姓名：娄丽梅 实验项目名称：DES加解密程序设计与实现 实验项目性质：设计性（验证性） 实验所属课程：信息安全 实验室(中心)：软件实验室 指导教师：米波 实验完成时间： 2014 年12月11日
一、实验目的 1、理解DES加密与解密的程序设计算法思想。 2、编写DES加密与解密程序，实现对明文的加密与解密，加深对数据加密与解密的理解，掌握DES加密算法思想，提高网络安全的编程能力。 二、实验主要内容及原理 （一）实验内容 1、掌握DES算法； 2、编写DES算法。 （二）实验原理 1、初始置换 初始置换在第一轮运算之前执行，对输入分组实施如下表所示的变换。此表应从左向右、从上向下读。在将这64位数据分为左右两部分，每部分分别为32位，将左32位留下，将右32位按照下表进行排列 2、密钥置换 一开始，由于不考虑每个字节的第8位，DES的密钥由64位减至56位。每个字节第8位可作为奇偶校验位以确保密钥不发生错误。接着，56位密钥被分成两部分，每部分28位。然后，根据轮数，这两部分分别循环左移l位或2位。在DES的每一轮中，从56位密钥选出48位子密钥（Sub Key）。 3、S盒置换 当产生了48位密钥后就可以和右边32位明文进行异或运算了，得到48位的密文。 再经过下论的S盒跌带，其功能是把6bit数据变为4bit数据，每个S盒是一个4行、16列的表。盒中的每一项都是一个4位的数。S盒的6个位输入确定了其对应的输出在哪一行哪一列。 4、P盒置换 S盒代替运算后的32位输出依照P盒进行置换。该置换把每输入位映射到输出位，任意一位不能被映射两次，也不能被略去，这个置换叫做直接置换。 5、再次异或运算 最后，将P盒置换的结果与最初的64位分组的左半部分异或，然后左、右半部分交换，接着开始另一轮。 6、当进行到16轮后，最终进行一次末置换，形成密文
一、DES加密及解密算法程序源代码： #include
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}, /*S2*/ {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}, /*S3*/ {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}, /*S4*/ {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}, /*S5*/ {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}, /*S6*/ {12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
Flash型单片机的加密与解密 厂商利用单片机进行产品开发时，都会关心其代码和数据的保密性。考虑到用户在编写和调试代码时所付出的时间和精力，代码的成本是不言而喻的。 早期的单片机，代码是交给芯片制造商制成掩膜ROM。有两种加密的机制，一是彻底破坏读取代码的功能，无论是开发者还是使用者都永远无法读取其中的内容。从安全上来说，这种方式很彻底 ，但是已经无法检查ROM中的代码了。另一种方法是不公开读取方法，厂商仍可以读取代码。这种方式留有检查代码的可能性，但是并不能算是一种真正的“加密”，被破解的可能性是存在的。 客观地讲，一方面希望加密很彻底，而另外一方面又希望留有检查代码的可能，这是相互矛盾 的要求。 自Flash技术得到广泛应用以来，各类单片机制造商纷纷采用了多种不同的芯片加密方法，对比掩膜ROM芯片来说，Flash ROM在线可编程特性使得芯片的加密和解密方式变得更加灵活和可靠。在Flash型单片机中，芯片的加密和解密工作都是通过对Flash ROM的编程来完成的，由于用户程序可以在线地改写ROM的内容，可以编写一套加密和解密的小程序，随用户程序下载到芯片中，通过运行该程序，在线修改Flash ROM的内容，对芯片进行加密和解密，使整个的加解密过程更为简单灵活。 Freescale公司的HCS12单片机采用的加解密思路有一定的典型性，我们对此作了一些研究，现以MC9S12DP256单片机为例，介绍Flash型单片机的加密解密方法。 BDM Freescale公司的很多单片机都借用一种被称为后台调试模式（Background Debug Mode，BDM）作为下载和调试程序的接口。 BDM是一种单线调试模式，芯片通过一个引脚与编程器进行通信。在HCS12系列单片机中，内部都置有标准的BDM调试模块。该模块的有三种作用： 1) 对内部存储器的读写。将用户程序下载到目标芯片中或是将存储器中的数据读出。 2) 对单片机工作方式和资源进行配置。部分涉及到单片机工作方式和资源配置的寄存器只能在特殊模式下由编程器发送BDM命令来修改。 3) 程序调试。利用BDM模块可以读写内存和CPU内部寄存器，调试程序。 在HCS12单片机未加密的状态下，使用BDM硬件命令可以将Flash ROM中的程序读出或将新的程序写入。BDM命令可以由独立的硬件系统来送出，我们一般称此类系统为BDM编程器。 BDM编程器的时序协议是公开的，任何人都可以根据协议设计硬件、编写程序，实现BDM编程器的功能。使用BDM接口，编程器可以很容易的访问到目标系统的存储器，这给程序调试和烧写带来了很大
第九章、实验报告 实验一、设置Windows启动密码 一、实验目的：利用Windows启动密码保存重要文件。 二、实验步骤： 1、在Windows XP系统中选择开始——运行，在打开输入框中“syskey.exe”,点击确定，打开“保证Windows XP账户数据库的安全”对话框。 2、单击【更新】，打开【启动密码】对话框，然后输入密码，在【确认】文本框中再次输入密码，单击【确定】
实验二、为word文档加密解密 一、实验目的:保护数据的安全 二、实验步骤： 1、打开一个需要加密的文档，选择【工具】——【选项】——【安全性】然后输入想要设置打开文件时所需的密码 2、单击【高级(A)】打开加密类型对话框，选中【加密文档属性】复选框，单击【确定】。
3、打开文件的【确认密码】对话框，输入打开文件时需要的密码，单击【确定】，随即打开【确认密码】对话框，输入密码。 4、保存文件后，重新打开Word文档，打开【密码】，输入打开文件所需的密码，单击【确定】输入修改的密码，单击【确定】 破解word密码 （1）安装Advanced Office Password Recovery软件，安装完成后打开需要破解的word 文档，进行暴力破解，结果如图所示： 实验三、使用WinRAR加密解密文件
一．实验目的：加密文件，保证文件的安全性。 二．实验步骤： 1、在需要加密的文件夹上右击，选中【添加到压缩文件】打开【压缩文件名和参数】 2、选中【压缩文件格式】组合框中的【RAR】并在【压缩选项】中选中【压缩后删除源文件】然后切换到【高级】，输入密码，确认密码。 3、关闭对话框，单击确定，压缩完成后，双击压缩文件，系统打开【输入密码对话框】 破解WinRAR加密的文件 （1）安装Advanced RAR Password Recovery软件，打开WinRAR加密文件，进行暴力破解，获得密码。结果如图：
3.4.5 SE丁协议的加解密过程 1。加密过程 首先，甲方要产生一个数字签名来向乙方证明信息确实是他发出的。他需要执行以 下步骤: ①将所发送信息通过哈希算法，形成信息摘要。 ②使用RSA算法，用私人签名密钥加密信息摘要，形成数字签名。 其次，甲方需要加密信息，使得它在网上传输时没有人能读懂它。 ③甲方通过软件，随机生成对称密钥，作大信息量加密之用，SET缺省的对称密钥 算法是DES o ④甲方用对称密钥加密所要发送的信息(即明文)、数字签名和证书。发送证书的目 的是为了乙方可从证书中得到公开签名密钥，以解开甲方的数字签名。 ⑥到目前为止，甲方可安全地发送信息了，同时也证明了他的身份。但为了使乙方 能读懂这些信息，甲方还需将对称密钥送给乙方。甲方用乙方的公开密钥加密该对称密钥，形成所谓的数字信封。最后甲方将数字信封和加密信息一同发给乙方。 2.解密过程 ①乙方用自己的私人密钥交换密钥将数字信封打开，取出对称密钥。 ②乙方用对称密钥解密信息，得到明文信息、数字签名和甲方的公开签名密钥(从 甲方的证书中获得)。 ③乙方用甲方的公开签名密钥解密数字签名，得到信息摘要。 3.验证过程 到目前为止，乙方还不知道收到的信息是否确实来自甲方，为了证实是甲方发送的信息，乙方还要完成以下步骤: ①将得到的明文信息进行哈希运算，得到新的信息摘要。 ②比较新的信息摘要和原信息摘要(上述解密过程中得到的)，如果两者一致，说明 收到的信息确实来自拥有与证书中公开签名密钥成对的私人签名密钥一方，而且信息是完整的。一旦乙方将证书送到发证机构CA认证，就可确定甲方的真实身份和证书是否有效。 3.4.6 SE丁协议分析 SET是基于信用卡的安全支付协议，用于保证信息的机密性、交易方身份的认证和信息的完整性。 (1)信息的机密性 在SET协议中，传输的信息都进行了加密处理，以保证信息的机密性。DES中SET 协议中默认的对称加密算法，用于保护敏感的金融数据;商用数据隐蔽设备CDMF(Commercial Data Mashing Facility)是另一种对称加密算法，用于SET中收单行和持卡者的信息保护它以DES为底层加密算法，采用40位密钥代替DES的64位密钥。为了保证信用卡信息不被商家非法获取，SET采用双重数据签名技术，以提供订购信息和支付消息的机密性，使商家只能看到订购信息，不能看到用户的信用卡信息，而银行只能看到信用卡信息，不能看到订购信息。 (2)数据的完整性 SET使用数字签名来保证数据的完整性。SET使用安全Hash算法SHA-1( Secure Hash Algorithm -1)及RSA来实现数字签名。SHA-1对于任意长度的消息都生成一个160位的消息摘要。如果消息中有一位发生变化，则消息摘要中的数据也会发生变化，两个不同的消息的摘要完全相同的概率几乎是零。 SET协议中还应用双重签名来保证信息的完整性。双重签名的目的是连接两个不同
课程设计任务书 2010—2011学年第二学期 专业：计算机科学与技术学号：080101010 姓名：刘海坤 课程设计名称：计算机网络课程设计 设计题目：加密解密软件的设计与实现 完成期限：自2011 年 6 月21 日至2011 年 6 月26 日共 1 周 设计目的: 本程序设计所采用的就是DES算法，同时利用Java的GUI编程，生成文本对话框，对文件的路径进行选择、提供密钥框、加密和解密按钮。 功能要求：根据DES算法，设计加密解密软件来为各种文件加密解密。 一、设计的任务：根据设计整体需求，本人负责窗体的设计与实现和目标文件 的导入模块。 二、进度安排： 三、主要参考资料： [1] 谢希仁.计算机网络教程.北京: 人民邮电出版社,2006. [2] 耿祥义.Java2使用教程:清华大学出版社,2006. [3] 方敏，张彤.网络应用程序设计.西安:电子科技大学出版社,2005. [4] 黄超.Windows下的网络编程.北京:人民邮电出版社,2003. 指导教师（签字）：教研室主任（签字）： 批准日期：年月日
摘要 随着计算机的应用和网络技术的不断发展，网络间的通讯量不断的加大，人们的个人信息、网络间的文件传递、电子商务等方面都需要大力的保护，文件加密技术也就随之产生。文件的加密主要是由加密算法实现，加密算法有多种，常见的有RSA、DES、MD5等。本程序设计对文件的加密使用的是DES加密算法。 DES是分块加密的。DES用软件进行解码需要用很长时间，而用硬件解码速度非常快，1977年，人们估计要耗资两千万美元才能建成一个专门计算机用于DES的解密，而且需要12个小时的破解才能得到结果。所以，当时DES被认为是一种十分强壮的加密方法。但今天，只需二十万美元就可以制造一台破译DES的特殊的计算机，所以现在 DES 对要求“强壮”加密的场合已经不再适用了。 Java语言具有简单、安全、可移植、面向对象、健壮、多线程、体系结构中立、解释执行、高性能、分布式和动态等主要特点。利用Java语言中秘密密钥工厂对DES算法的支持，使程序实现文件加密、解密两大功能更简单。 本程序设计所采用的就是DES算法。同时利用Java的GUI编程，生成文本对话框，对文件的路径进行选择、提供密钥框、加密和解密按钮。 使用本程序可以对txt，word等多种文件进行加密解密，使用便捷实用，功能完善，满足了用户对文件安全性的需求。 关键词：JA V A ，DES，加密，解密。
实验报告 课程：计算机保密_ _ 实验名称：数据的加密与解密_ _ 院系(部)：计科院_ _ 专业班级：计科11001班_ _ 学号： 201003647_ _ 实验日期： 2013-4-25_ _ 姓名： _刘雄 _ 报告日期： _2013-5-1 _ 报告评分：教师签字：
一. 实验名称 数据加密与解密 二.运行环境 Windows XP系统 IE浏览器 三.实验目的 熟悉加密解密的处理过程，了解基本的加密解密算法。尝试编制基本的加密解密程序。掌握信息认证技术。 四.实验内容及步骤 1、安装运行常用的加解密软件。 2、掌握加解密软件的实际运用。 *3、编写凯撒密码实现、维吉尼亚表加密等置换和替换加解密程序。 4、掌握信息认证的方法及完整性认证。 （1）安装运行常用的加解密软件,掌握加解密软件的实际运用 任务一：通过安装运行加密解密软件（Apocalypso.exe；RSATool.exe；SWriter.exe等（参见：实验一指导））的实际运用，了解并掌握对称密码体系DES、IDEA、AES等算法，及非对称密码体制RSA等算法实施加密加密的原理及技术。 ?DES：加密解密是一种分组加密算法，输入的明文为64位，密钥为56位，生成的密文为64位。 ?BlowFish：算法用来加密64Bit长度的字符串或文件和文件夹加密软件。 ?Gost(Gosudarstvennyi Standard)：算法是一种由前苏联设计的类似DES算法的分组密码算法。它是一个64位分组及256位密钥的采用32轮简单迭代型加密算法. ?IDEA：国际数据加密算法：使用128 位密钥提供非常强的安全性； ?Rijndael：是带有可变块长和可变密钥长度的迭代块密码（AES 算法）。块长和密钥长度可以分别指定成128、192 或256 位。 ?MISTY1：它用128位密钥对64位数据进行不确定轮回的加密。文档分为两部分：密钥产生部分和数据随机化部分。 ?Twofish：同Blowfish一样，Twofish使用分组加密机制。它使用任何长度为256比特的单个密钥，对如智能卡的微处理器和嵌入在硬件中运行的软件很有效。它允许使用者调节加密速度，密钥安装时间，和编码大小来平衡性能。 ?Cast-256：AES 算法的一种。 （同学们也可自己下载相应的加解密软件，应用并分析加解密过程） 任务二：下载带MD5验证码的软件（如：https://www.doczj.com/doc/611260942.html,/downloads/installer/下载（MySQL）：Windows (x86, 32-bit), MSI Installer 5.6.11、1.5M；MD5码: 20f788b009a7af437ff4abce8fb3a7d1），使用MD5Verify工具对刚下载的软件生成信息摘要，并与原来的MD5码比较以确定所下载软件的完整性。或用两款不同的MD5软件对同一文件提取信息摘要，而后比较是否一致，由此可进行文件的完整性认证。
《Network Security Technology》Experiment Guide Encryption Algorithm Lecture Code: 011184 Experiment Title：加密算法 KeyWords：MD5, PGP, RSA Lecturer：Dong Wang Time：Week 04 Location：Training Building 401 Teaching Audience：09Net1&2 October 10, 2011
实验目的： 1，通过对MD5加密和破解工具的使用，掌握MD5算法的作用并了解其安全性； 2，通过对PGP加密系统的使用，掌握PGP加密算法的作用并了解其安全性； 3，对比MD5和PGP两种加密算法，了解它们的优缺点，并总结对比方法。 实验环境： 2k3一台，XP一台，确保相互ping通； 实验工具：MD5V erify, MD5Crack, RSA-Tools,PGP8.1 MD5加密算法介绍 当前广泛存在有两种加密方式，单向加密和双向加密。双向加密是加密算法中最常用的，它将明文数据加密为密文数据，可以使用一定的算法将密文解密为明文。双向加密适合于隐秘通讯，比如，我们在网上购物的时候，需要向网站提交信用卡密码，我们当然不希望我们的数据直接在网上明文传送，因为这样很可能被别的用户“偷听”，我们希望我们的信用卡密码是通过加密以后，再在网络传送，这样，网站接受到我们的数据以后，通过解密算法就可以得到准确的信用卡账号。 单向加密刚好相反，只能对数据进行加密，也就是说，没有办法对加密以后的数据进行解密。这有什么用处？在实际中的一个应用就是数据库中的用户信息加密，当用户创建一个新的账号或者密码，他的信息不是直接保存到数据库，而是经过一次加密以后再保存，这样，即使这些信息被泄露，也不能立即理解这些信息的真正含义。 MD5就是采用单向加密的加密算法，对于MD5而言，有两个特性是很重要的，第一是任意两段明文数据，加密以后的密文不能是相同的；第二是任意一段明文数据，经过加密以后，其结果必须永远是不变的。前者的意思是不可能有任意两段明文加密以后得到相同的密文，后者的意思是如果我们加密特定的数据，得到的密文一定是相同的。不可恢复性是MD5算法的最大特点。 实验步骤- MD5加密与破解： 1，运行MD5Verify.exe，输入加密内容‘姓名（英字）’，生成MD5密文；
AES算法加解密原理及安全性分析 刘帅卿 一、AES算法简介 AES算法是高级加密标准算法的简称，其英文名称为Advanced Encryption Standard。该加密标准的出现是因为随着对称密码的发展,以前使用的DES（Data Encryption Standard数据加密标准）算法由于密钥长度较小(56位),已经不适应当今数据加密安全性的要求，因此后来由Joan Daeman和Vincent Rijmen提交的Rijndael算法被提议为AES的最终算法。 AES是一个迭代的、对称密钥分组的密码，它可以使用128、192和256位密钥，并且用128位(16字节)分组加密和解密数据。与公共密钥密码使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。通过分组密码返回的加密数据的位数与输入数据相同。迭代加密使用一个循环结构，在该循环中重复置换(permutations)和替换(substitutions)输入数据。加之算法本身复杂的加密过程使得该算法成为数据加密领域的主流。 二、AES算法的基本概念 1、有限域（GF） 由于AES算法中的所有运算都是在有限域当中进行的，所以在理解和实现该算法之前先得打好有限域这一基石才行。通常的数学运算都是在实数域中进行，而AES算法则是在有限域中进行，我们可以将有限域看成是有确定边界范围的正整数集合，在该集合当中，任意两个元素之间的运算结果都仍然落在该集合当中，也即满足运算封闭性。 那么如何才能保证这样的“有限性”（也即封闭性）呢？ GF（2w）被称之为伽罗华域，是有限域的典型代表。随着w（=4,8,16,…）的取值不同所形成的有限域范围也不同。AES算法中引入了GF域当中对数学运算的基本定义：将两数的加减法定义为两者的异或运算；将两数的乘法定义为多
启动：net start mySql; 进入：mysql -h localhost -u root -p databaseName; 列出数据库：show databases; 选择数据库：use databaseName; 列出表格：show tables； 显示表格列的属性：show columns from tableName； 建立数据库：source fileName.txt; 匹配字符：可以用通配符_代表任何一个字符，％代表任何字符串; 增加一个字段：alter table tabelName add column fieldName dateType; 增加多个字段：alter table tabelName add column fieldName1 dateType,add columns fieldName2 dateType; 多行命令输入:注意不能将单词断开;当插入或更改数据时，不能将字段的字符串展开到多行里，否则硬回车将被储存到数据中; 增加一个管理员帐户：grant all on *.* to user@localhost identified by "password"; 每条语句输入完毕后要在末尾填加分号';'，或者填加'\g'也可以； 查询时间：select now(); 查询当前用户：select user(); 查询数据库版本：select version(); 查询当前使用的数据库：select database(); 1、删除student_course数据库中的students数据表： rm -f student_course/students.* 2、备份数据库：(将数据库test备份) mysqldump -u root -p test>c:\test.txt 备份表格：(备份test数据库下的mytable表格) mysqldump -u root -p test mytable>c:\test.txt 将备份数据导入到数据库：(导回test数据库) mysql -u root -p test 3、创建临时表：(建立临时表zengchao) create temporary table zengchao(name varchar(10)); 4、创建表是先判断表是否存在 create table if not exists students(……); 5、从已经有的表中复制表的结构 create table table2 select * from table1 where 1<>1; 6、复制表 create table table2 select * from table1; 7、对表重新命名 alter table table1 rename as table2; 8、修改列的类型
信息安全工程课程 实验报告 AES加密解密的实现 课程名称：信息安全工程 学生姓名：黄小菲 学生学号： 3112041006 专业班级：系统工程2038班 任课教师：蔡忠闽 2012年11月22日
目录 1．背景 (1) 1.1 Rijndael密码的设计标准： (1) 1.2 设计思想 (1) 2.系统设计 (2) 2.1系统主要目标 (2) 2.2功能模块与系统结构 (2) 2.2.1字节替换SubByte (2) 2.2.2行移位ShiftRow (2) 2.2.3 列混合MixColumn (3) 2.2.4 轮密钥加AddRoundKey (4) 2.2.5 逆字节替换 (4) 2.2.6逆行移位InvShiftRow (4) 2.2.7 逆列混淆 (4) 3 加密模式 (5) 3.1 电子密码本ECB模式 (5) 3.2加密块链模式CBC模式 (6) 4 系统功能程序设计 (8) 4.1基本加密部分 (8) 4.1.1字节替换 (8) 4.1.2行移位 (8) 4.1.3列混合 (9) 4.1.4轮密钥加 (9) 4.1.5密钥扩展 (10) 4.1.6逆字节替换 (11) 4.1.7逆行移位 (11) 4.1.8逆列混合 (12) 4.1.9加密 (12) 4.1.10解密 (13) 5 实验结果 (14) 5.1 需要加密文件 (14) 5.2 实验加密解密结果 (15) 6 参考资料 (16)
1．背景 AES，密码学中的高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。AES 有一个固定的128位的块大小和128，192或256位大小的密钥大小。Rijndael算法汇聚了安全性、效率高、易实现性和灵活性等优点,是一种较DES更好的算法。 该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael之命名之，投稿高级加密标准的甄选流程。（Rijdael的发音近于"Rhine doll"。）AES在软体及硬件上都能快速地加解密，相对来说较易于实作,且只需要很少的记忆体。作为一个新的加密标准,目前正被部署应用到更广大的范围. 1.1 Rijndael密码的设计标准： ①抵抗所有已知的攻击。 ②在多个平台上速度快，编码紧凑。 ③设计简单。 当前的大多数分组密码，其轮函数是Feistel结构。 Rijndael没有这种结构。 Rijndael轮函数是由3个不同的可逆均匀变换 1.2 设计思想 ?分组和密钥长度可变，各自可独立指定为128、192、256比特。 ?状态 ?算法中间的结果也需要分组，称之为状态，状态可以用以字节为元素的矩阵 阵列表示，该阵列有4行，列数N b为分组长度除32 ?种子密钥 ?以字节为元素的矩阵阵列描述，阵列为4行，列数N k为密钥长度除32
第21卷第5期2005年10月 赤峰学院学报(自然科学版) Journal of Chifeng College(Natural Science Edition) Vol.21No.5 Oct.2005数据加密技术分析及应用 郭敏杰 (内蒙古伊泰丹龙药业有限责任公司,内蒙古 赤峰 024000) 摘 要:数据加密技术是实现网络安全的关键技术之一.本文系统地介绍了当前广泛使用的几种数据加密技术:对称密钥加密、公开密钥加密以及混合式加密,对它们进行了客观上的分析并介绍了在网络及其他方面的应用状况. 关键词:数据加密;密钥;网络安全 中图分类号:TP309.7文献标识码:A文章编号:1673-260X(2005)05-0041-01 伴随微机的发展与应用,数据的安全越来越受到高度的重视.数据加密技术就是用来保证信息安全的基本技术之一.数据加密实质是一种数据形式的变换,把数据和信息(称为明文)变换成难以识别和理解的密文并进行传输,同时在接收方进行相应的逆变换(称为解密),从密文中还原出明文,以供本地的信息处理系统使用.加密和解密过程组成为加密系统,明文和密文统称为报文. 1 对称密钥加密算法 对称式密钥加密技术是指加密和解密均采用同一把秘密钥匙,而且通信双方必须都要获得这把钥匙,并保持钥匙的秘密.当给对方发信息时,用自己的加密密钥进行加密,而在接收方收到数据后,用对方所给的密钥进行解密. 对称密钥加密有许多种算法,但所有这些算法都有一个共同的目的———以可还原的方式将明文(未加密的数据)转换为暗文.暗文使用加密密钥编码,对于没有解密密钥的任何人来说它都是没有意义的.由于对称密钥加密在加密和解密时使用相同的密钥,所以这种加密过程的安全性取决于是否有未经授权的人获得了对称密钥.这就是它为什么也叫做机密密钥加密的原因.希望使用对称密钥加密通信的双方,在交换加密数据之前必须先安全地交换密钥. 加密算法中最简单的一种就是“置换表”算法,这种算法也能很好达到加密的需要.每一个数据段(总是一个字节)对应着“置换表”中的一个偏移量,偏移量所对应的值就输出成为加密后的文件.加密程序和解密程序都需要一个这样的“置换表”.事实上,80×86cpu系列就有一个指令`xlat'在硬件级来完成这样的工作.这种加密算法比较简单,加密解密速度都很快,但是一旦这个“置换表”被对方获得,那这个加密方案就完全被识破了.更进一步讲,这种加密算法对于黑客破译来讲是相当直接的,只要找到一个“置换表”就可以了.这种方法在计算机出现之前就己经被广泛的使用. 对这种“置换表”方式的一个改进就是使用2个或者更多的“置换表”,这些表都是基于数据流中字节的位置的,或者基于数据流本身.这时,破译变的更加困难,因为黑客必须正确地做几次变换.通过使用更多的“置换表”,并且按伪随机的方式使用每个表,这种改进的加密方法已经变的很难破译. 2 基于公钥的加密算法 基于公钥的加密算法有两种方式:对称密钥算法和非对称密钥算法.所谓对称密钥加密方法中,对信息的加密和解密都使用相同的密钥,或者可以从一个密钥推导出另一个密钥,而且通信双方都要获得密钥并保持密钥的秘密.当需要对方发送信息时,用自己的加密密钥进行加密,而在接受方收到数据后,用对方所给的密钥进行解密. 非对称密钥算法就是加密解密使用不同的密钥.这种算法的基本原理是利用两个很大的质数相乘所产生的乘积来加密,这两个质数无论哪个先与原文件编码相乘、对文件加密,均可由另一个质数再相乘来解密,但要用一个质数来求出另一个质数则是十分困难的. 非常著名的pgp公钥加密以及rsa加密方法都是非对称加密算法. 3 对称密钥和公钥相结合的加密技术 根据对称密钥和公钥加密特点,在实际应用中将二者相结合,即使用DES/IDE A和RSA结合使用.首先发信者使用DES/IDEA算法用对称钥将明文原信息加密获得密文,然后使用接受的RSA公开钥将对称钥加密获得加密的DES或IDE A密钥,将密文和密钥一起通过网络传送给接收者.接受方接受到密文信息后,先用自己的密钥解密而获得DES或IDEA密钥,再用这个密钥将密文解密而后获得明文原信息.由此起到了对明文信息保密作用. 4 加密技术的应用及发展 随着网络互联技术的发展,信息安全必须系统地从体系结构上加以考虑.ORI(开放系统互联)参考模型的七 (下转第44页) · 41 · DOI:10.13398/https://www.doczj.com/doc/611260942.html, ki.issn1673-260x.2005.05.024
程序设计报告 （ 2012 /2013 学年第一学期） 题目：文件加解密处理程序 专业 学生姓名 班级学号 指导教师燕俐 指导单位计算机系统结构与网络教学中心日期 2012.12.10～12.21
一、课题容及要求 1.功能要求 编写一个对文件（由数字或字母组成）进行加密解密的程序。可以将所需要的容（整个文件或者输入的一行字符）加密，也可以将存储的加密文件翻译回来。例如加密时可以将选取容的每个字符依次反复加上”49632873”中的数字,如果围超过ASCII码值的032(空格)—122(‘z’),则进行模运算(既N%122).解密与加密的顺序相反。 2.菜单要求： 从键盘输入要进行加密的一行字符串或者需要加密的文件名。显示菜单： 1.设置加密方法 2.加密 3.解密 4.显示原始文件和解密文件 选择菜单，进行相应的操作。加密方法是设置一加密字符串以及对文件的哪些部分进行加密；加密是将原始文件加密并保存到文件中；解密是将加了密的文件还原并保存到文件中，同时应比较与原始文件的一致性；显示是将文件在屏幕上显示出来，供人工校对。 3. 程序设计参考思路： (1)定义原始文件sourse.txt、加密文件result.txt和还原文件recall.txt (2) 程序模块及函数功能： （1）在屏幕上显示文件 void printtxt(); （2）加密void encode(); （3）解密void decode(); （4）文件比较void cmptxt(); 4.需要的知识： （1）文件读取写入操作语言 （2）字符串的处理，如何对字符进行加减操作，并保证加减后的数值处于某一围之（模运算） （3）了解加解密的基本原理 二、需求分析
DES加密与解密算法 课程名称：工程实践 学生姓名： xxxx 学生学号： xxxx 专业班级： xxxx 任课教师： xxxx 论文提交日期： xxxx
DES加密与解密算法 摘要 本世纪五十年代以来，密码学研究领域出现了最具代表性的两大成就。其中之一就是1971年美国学者塔奇曼（Tuchman）和麦耶（Meyer）根据信息论创始人香农（Shannon）提出的“多重加密有效性理论”创立的，后于1977年由美国国家标准局颁布的数据加密标准。 DES密码实际上是Lucifer密码的进一步发展。它是一种采用传统加密方法的区组密码。它的算法是对称的，既可用于加密又可用于解密。 1977年1月，美国政府颁布：采纳IBM公司设计的方案作为非机密数据的正式数据加密标准（DES枣Data Encryption Standard）。 目前在这里，随着三金工程尤其是金卡工程的启动，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡持卡人的PIN的加密传输，IC卡与POS间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。 关键词：DES算法，加密，解密
Abstract This century since fifty time, cryptography research field is the most representative of the two Achievement. One was the 1971 USA scholar Tuchman (Tuchman) and Meyer (Meyer) based on information theory founder Shannon (Shannon) proposed "multiple encryption effectiveness theory" was founded, in 1977 after the National Bureau of standards promulgated by the America data encryption standard.The DES password is actually a further development of the Lucifer password. It is a traditional encryption method of block cipher. The algorithm is symmetric, which can be used for encryption and decryption can be used. In 1977 January, the government promulgated American: adopted IBM design as a non official data confidential data encryption standard (DES - Data Encryption Standard). At present here, along with three gold project especially golden card project startup, DES algorithm in POS, ATM, magnetic card and intelligent card (IC card), gas station, highway toll station and other fields are widely used, so as to realize the security of key data encryption transmission, such as credit card holders PIN, IC card and POS mutual authentication, financial transaction data package of MAC check and so on, are used in DES algorithm. Keywords: DES algorithm, encryption, decryption