import java.util.Scanner;
public class Caeser {
private String table; // 定义密钥字母表
private int key; // 定义密钥key
public Caeser(String table, int key) {
// 根据不同的字母表和不同的密钥生成一个新的凯撒算法，达到通用的目的
super();
this.table = table;
this.key = key;
}
public String encrypt(String from) {
//凯撒加密算法，传入明文字符串，返回一个密文字符串
String to = "";
for (int i = 0; i < from.length(); i++) {
to += table.charAt((table.indexOf(from.charAt(i))+key)%table.length());
}
return to;
}
public static void main(String[] args) {
Caeser caeser = new Caeser("abcdefghijklmnopqrstuvwxyz", 3);
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要加密的字符串");
String str =scanner.nextLine(); //输入字符串 security
String result = caeser.encrypt(str); //调用加密方法进行加密
System.out.print(result); // 可得结果 vhfxulwb
}
}
B. 用汇编语言编写 简易加密解密程序
; 本程序通过编译，运行正确
Code Segment
Assume CS:Code,DS:Code
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 功能：显示指定地址（Str_Addr）的字符串
; 入口：
; Str_Addr＝字符串地址（要求在数据段）
; 用法: Output Str_Addr
; 用法举例：Output PromptStr
Output MACRO Str_Addr
push dx
lea dx,Str_Addr
mov ah,9
int 21h
pop dx
EndM
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 功能：打开指定路径下的文件。若打开成功，保存文件代号，设置进位标志；
; 否则，建立文件，保存文件代号，清进位标志
; 入口参数：dx=文件名地址，bx=文件代号保存地址
Open_File Proc Near
mov ax,3d02h ;以读写方式打开文件
int 21h
jc @@Error
mov [bx],ax ;成功打开，保存文件代号
stc ;设置进位标志
ret
@@Error: Output Open_Error
xor cx,cx ;新建文件属性
Create_File:mov ah,3ch ;建立文件
int 21h
jc Create_File ;建立不成功，尝试再建
mov [bx],ax ;成功建立，保存文件代号
clc ;清进位标志
ret
Open_File EndP
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 功能：对字符串缓冲区中的内容逐个字符加密
; 入口参数：si=字符串地址，cx=字符数
Encode_Str Proc Near
push si
push cx
lea di,Handle_File
mov al,[di][88] ;读取密钥
@@Encoding: xor byte ptr [si],al ;异或，第一步加密
push cx
mov cx,188
rol byte ptr [si],cl ;循环左移188位，第二步加密
pop cx
inc si ;下一个字符地址
loop @@Encoding ;处理下一个字符
pop cx
pop si
ret
Encode_Str EndP
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 功能：对字符串缓冲区中的内容逐个字符加密
; 入口参数：si=字符串地址，cx=字符数
Uncode_Str Proc Near
push si
push cx
lea di,Handle_File
mov al,[di][88] ;读取密钥
@@Uncoding: push cx
mov cx,188
ror byte ptr [si],cl ;循环右移188位，第一步解密
pop cx
xor byte ptr [si],al ;异或，第二步解密
inc si ;下一个字符地址
loop @@Uncoding ;处理下一个字符
pop cx
pop si
ret
Uncode_Str EndP
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Handle_File dw ?,?,? ;文件代号
File_Name1 db 'c:\masm\rory00.txt',0 ;未加密的文本文件
File_Name2 db 'c:\masm\rory01.txt',0 ;加密后的文本文件
File_Name3 db 'c:\masm\rory02.txt',0 ;解密后的文本文件
Open_Error db 'Open file error,creat a new file.',13,10,13,10,7,'$'
Input_New db 'Input the new information:',13,10,'$'
Press_Key db 13,10,13,10,'The Encode and Uncode have been completed.',7
db 13,10,13,10,'Press any key to exit...$'
Start: push cs
pop ds
push cs
pop es ;使数据段、附加段与代码段同段
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 打开或建立三个文件
lea dx,Buffer ;文本内容处理缓冲区
mov cx,0ffc0h ;预留32个字的堆栈空间
sub cx,dx ;设置读写一次文件内容的字节数
mov bp,cx ;暂存
lea dx,File_Name2 ;文件名地址
lea bx,Handle_File[2] ;文件代号保存地址
call Open_File ;打开指定路径下的文件。若打开成功，保存文件代号；否则，建立文件，保存文件代号
lea dx,File_Name3 ;文件名地址
lea bx,Handle_File[4] ;文件代号保存地址
call Open_File
lea ax,@@jump000
push ax
call @@Locate_01
@@Locate_00:lea dx,File_Name1 ;文件名地址
lea bx,Handle_File ;文件代号保存地址
call Open_File
jc Read_File
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 若是新建文件，输入文件内容，实施加密，写到另一个文件
Input_Str: Output Input_New ;提示输入新信息
lea dx,Buffer ;文本内容处理缓冲区
mov ah,0ah ;键盘输入字符串
int 21h
lea si,Buffer[1] ;实际输入的字符个数地址
lodsb ;读取实际输入的字符数
test al,0ffh
jz Input_Str ;若直接回车，未输入任何字符，再次提示输入新信息
mov dx,si ;数据缓冲区地址
mov cl,al ;实际输入的字符数
xor ch,ch
mov bx,Handle_File ;读取未加密的文本文件代号
Write_Uncod:mov ah,40h
int 21h
jc Write_Uncod ;写入失败，尝试再写
call Encode_Str ;逐个字符加密
mov dx,si ;数据缓冲区地址，要写入的字符数已在cx中
mov bx,Handle_File[2] ;文件代号
Write_Coded:mov ah,40h
int 21h
jc Write_Coded ;写入失败，尝试再写
jmp @@Uncode
@@Locate_01:pop ax
ret
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 若成功打开文件，读取文件内容，实施加密，写到另一个文件
Read_File: lea dx,Buffer ;文本内容处理缓冲区
mov cx,bp
mov bx,Handle_File ;读取未加密的文本文件代号
mov ah,3fh ;读文件内容
int 21h
jc Read_File ;读文件失败，尝试再读
test ax,0ffffh
jz @@Uncode ;若实际读取的字节数为0，结束读写操作
lea si,Buffer
mov cx,ax
call Encode_Str ;逐个字符加密
mov dx,si ;数据缓冲区地址，要写入的字符数已在cx中
mov bx,Handle_File[2] ;读取目标文件代号
Write_File: mov ah,40h ;写文件
int 21h
jc Write_File ;写文件失败，尝试再写
jmp Read_File
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 修改子程序Encode_Str和Encode_Str中的循环移位次数
@@jump000: mov byte ptr Encode_Str[13],6
mov byte ptr Uncode_Str[11],6
lea ax,@@Locate_00
push ax
call @@Locate_01
; －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
; 将加密完的内容解密，写入第三个文本文件
@@Uncode: xor dx,dx
xor cx,cx
Loca_Seek1: mov bx,Handle_File[4] ;读取解密后的文本文件代号
mov ax,4200h ;移动文件指针至文件头
int 21h
jc Loca_Seek1
Loca_Seek2: mov bx,Handle_File[2] ;读取加密后的文本文件代号
mov ax,4200h ;移动文件指针至文件头
int 21h
jc Loca_Seek2
lea dx,Buffer ;文本内容处理缓冲区
Read_File1: mov cx,bp
mov bx,Handle_File[2] ;读取加密后的文本文件代号
mov ah,3fh ;读文件内容
int 21h
jc Read_File1 ;读文件失败，尝试再读
test ax,0ffffh
jz Close_File1 ;若实际读取的字节数为0，结束读写操作，关闭文件
lea si,Buffer
mov cx,ax
call Uncode_Str ;逐个字符解密
mov dx,si ;数据缓冲区地址，要写入的字符数已在cx中
mov bx,Handle_File[4] ;读取解密后的文本文件代号
Write_File1:mov ah,40h ;写文件
int 21h
jc Write_File1 ;写文件失败，尝试再写
jmp Read_File1
Close_File1:mov bx,Handle_File ;读取未加密的文本文件代号
mov ah,3eh ;关闭文件
int 21h
jc Close_File1
Close_File2:mov bx,Handle_File[2] ;读取加密后的文本文件代号
mov ah,3eh ;关闭文件
int 21h
jc Close_File2
Close_File3:mov bx,Handle_File[4] ;读取解密后的文本文件代号
mov ah,3eh ;关闭文件
int 21h
jc Close_File3
Output Press_Key ;提示操作完成，按任意键结束程序
mov ah,1
int 21h
Exit_Proc: mov ah,4ch ;结束程序
int 21h
ALIGN 10h ;节对齐
Buffer db 255 ;文本内容处理缓冲区
Code ENDS
END Start ;编译到此结束
C. 编写程序，实现对任意字符串的加密和解密操作
Dim a() As String, b() As Integer, n As Integer
Text2 = ""
n = Len(Text1)
ReDim a(n)
ReDim b(n + 3)
For i = 1 To n
a(i) = Mid(Text1, i, 1)
If (Asc(a(i)) >= 65 And Asc(a(i)) <= 90) Or (Asc(a(i)) >= 97 And Asc(a(i)) <= 122) Then
b(i) = Asc(a(i)) + 3
If b(i) > Asc("Z") And b(i) < Asc("a") Then b(i) = Asc("A") + b(i) - Asc("Z") - 1
If b(i) > Asc("z") Then b(i) = Asc("a") + b(i) - Asc("z") - 1
Else
b(i) = Asc(a(i))
End If
a(i) = Chr(b(i))
Text2 = Text2 & a(i)
Next
Text3 = Text2
End Sub
Private Sub Command2_Click()
Dim a() As String, b() As Integer, n As Integer
Text4 = ""
n = Len(Text3)
ReDim a(n)
ReDim b(n + 3)
For i = 1 To n
a(i) = Mid(Text3, i, 1)
If (Asc(a(i)) >= 65 And Asc(a(i)) <= 90) Or (Asc(a(i)) >= 97 And Asc(a(i)) <= 122) Then
b(i) = Asc(a(i)) - 3
If b(i) >= 62 And b(i) < Asc("A") Then b(i) = Asc("Z") - (Asc("A") + b(i)) + 1
If b(i) >= 94 And b(i) < Asc("a") Then b(i) = Asc("z") - Asc("a") + b(i) + 1
Else
b(i) = Asc(a(i))
End If
a(i) = Chr(b(i))
Text4 = Text4 & a(i)
Next
End Sub
为便于调试对照，其中将加密后的文件直接放在了TEXT3中。调试完可去掉
D. C++ 一个关于加密解密的程式 写注解
那几个头文件按是编程者自己加上去的。
因为，代码中用到了若干库函数，例如remove(), rename(0, getch(), isdigit(), puts()等等
有些库函数不是在stdio.h中声明的，所以编译的时候会提示没有对应的函数，
需要把那些函数所对应的头文件包含进来。
E. c++怎么编写程序实现文件加密和解密
#include <iostream>
#define BufLength 100
void Encrypted_Decrypt(char* filepath, char* sec, int seclegth)
{
FILE * file = fopen(filepath, "r+");
if (NULL == file)
{
std::cout << "打开文件出错" << std::endl;
return;
}
char buffer[BufLength];
char secret[BufLength];
int n = 0;
while ((n = fread(buffer, 1, BufLength, file))> 0)
{
for (int i = 0; i < n; i++)
secret[i] = buffer[i] ^ sec[i % (seclegth + 1)];//加密
fseek(file, -n, SEEK_CUR);//移动字符串头在文件中的位置
fwrite(secret, 1, n, file);//覆盖写入秘文
fseek(file, n, SEEK_CUR);//移动字符串尾在文件中的位置,下次循环读取下一串
}
fclose(file);
}
int main()
{
std::cout << "输入密码:";
char psw[256];
std::cin >> psw;
std::cout << "加密或者解密文件(全路径如d:/1.txt):";
char filepath[256];
std::cin >> filepath;
Encrypted_Decrypt(filepath, psw, strlen(psw));
return 0;
}
F. java编写数字加密解密
//package wangcai.test;
public interface Endecryption {
public static final byte[] EN={48,49,50,51,52,53,54,55,56,57};
public static final byte[] DE={55,53,57,49,51,54,56,48,50,52};
}
//package wangcai.test;
import java.util.Scanner;
public class Cryption implements Endecryption{
/*
* 原始数字与加密后得到的密文数字之间的对应关系如下：
原始数字：0 1 2 3 4 5 6 7 8 9
密文数字：7 5 9 1 3 6 8 0 2 4
试编写程序把原始数字转换成加密密文或把加密密文转换成原始数字。
输入：
1 6 （第一个数表示加密或解密：1加密，2解密；第二个数表示数字的个数）
1 9 9 7 7 1 （待处理的数字内容）
输出：
5 4 4 0 0 5
*/
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
Cryption c=new Cryption();
System.out.println("请输入是加密还是解密：1加密，2解密");
int ende=sc.nextInt();
if(ende==1)
{
System.out.println("请输入加密的数字个数");
int num=sc.nextInt();
System.out.println("请输入"+num+"个数字");
String temp=new Scanner(System.in).nextLine();
System.out.println(c.Encryption(temp));
}
else if(ende==2)
{
System.out.println("请输入解密的数字个数");
int num=sc.nextInt();
System.out.println("请输入"+num+"个数字");
String temp=new Scanner(System.in).nextLine();
System.out.println(c.Decryption(temp));
}
else
{
System.out.println("输入错误");
}
}
/**
* 加密
* @param temp
* @return
*/
public String Encryption(String temp)
{
String result="";
byte[] temp_byte=temp.getBytes();
for(byte b:temp_byte)
{
int i=0;
for(;i<EN.length;i++)
{
if(b==EN[i])
{
result+=(char)DE[i];
break;
}
}
if(i==EN.length)
{
result+=(char)b;
}
}
return result;
}
/**
* 解密
* @param temp
* @return
*/
public String Decryption(String temp)
{
String result="";
byte[] temp_byte=temp.getBytes();
for(byte b:temp_byte)
{
int i=0;
for(;i<DE.length;i++)
{
if(b==DE[i])
{
result+=(char)EN[i];
break;
}
}
if(i==DE.length)
{
result+=(char)b;
}
}
return result;
}
}
加密解密方面的一般采用byte来实现
G. C语言编写对文件加密及解密
常用简单的加密就是把字符移位，读取一个字符，将它+100，然后存为新文件中，解密时就读取-100，然后就是原文件了。还有就是读个字符和一个值异或，解密时还用这个加密的异或一遍，比较省力，一个方法就完成加解密了。
H. java加密解密代码
package com.cube.limail.util;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;/**
* 加密解密类
*/
public class Eryptogram
{
private static String Algorithm ="DES";
private String key="CB7A92E3D3491964";
//定义 加密算法,可用 DES,DESede,Blowfish
static boolean debug = false ;
/**
* 构造子注解.
*/
public Eryptogram ()
{
} /**
* 生成密钥
* @return byte[] 返回生成的密钥
* @throws exception 扔出异常.
*/
public static byte [] getSecretKey () throws Exception
{
KeyGenerator keygen = KeyGenerator.getInstance (Algorithm );
SecretKey deskey = keygen.generateKey ();
System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()));
if (debug ) System.out.println ("生成密钥:"+bytesToHexString (deskey.getEncoded ()));
return deskey.getEncoded ();
} /**
* 将指定的数据根据提供的密钥进行加密
* @param input 需要加密的数据
* @param key 密钥
* @return byte[] 加密后的数据
* @throws Exception
*/
public static byte [] encryptData (byte [] input ,byte [] key ) throws Exception
{
SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
if (debug )
{
System.out.println ("加密前的二进串:"+byte2hex (input ));
System.out.println ("加密前的字符串:"+new String (input ));
} Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.ENCRYPT_MODE ,deskey );
byte [] cipherByte =c1.doFinal (input );
if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));
return cipherByte ;
} /**
* 将给定的已加密的数据通过指定的密钥进行解密
* @param input 待解密的数据
* @param key 密钥
* @return byte[] 解密后的数据
* @throws Exception
*/
public static byte [] decryptData (byte [] input ,byte [] key ) throws Exception
{
SecretKey deskey = new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));
Cipher c1 = Cipher.getInstance (Algorithm );
c1.init (Cipher.DECRYPT_MODE ,deskey );
byte [] clearByte =c1.doFinal (input );
if (debug )
{
System.out.println ("解密后的二进串:"+byte2hex (clearByte ));
System.out.println ("解密后的字符串:"+(new String (clearByte )));
} return clearByte ;
} /**
* 字节码转换成16进制字符串
* @param byte[] b 输入要转换的字节码
* @return String 返回转换后的16进制字符串
*/
public static String byte2hex (byte [] b )
{
String hs ="";
String stmp ="";
for (int n =0 ;n <b.length ;n ++)
{
stmp =(java.lang.Integer.toHexString (b [n ] & 0XFF ));
if (stmp.length ()==1 ) hs =hs +"0"+stmp ;
else hs =hs +stmp ;
if (n <b.length -1 ) hs =hs +":";
} return hs.toUpperCase ();
}
/**
* 字符串转成字节数组.
* @param hex 要转化的字符串.
* @return byte[] 返回转化后的字符串.
*/
public static byte[] hexStringToByte(String hex) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
for (int i = 0; i < len; i++) {
int pos = i * 2;
result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
}
return result;
}
private static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF".indexOf(c);
return b;
}
/**
* 字节数组转成字符串.
* @param String 要转化的字符串.
* @return 返回转化后的字节数组.
*/
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = Integer.toHexString(0xFF & bArray[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
/**
* 从数据库中获取密钥.
* @param deptid 企业id.
* @return 要返回的字节数组.
* @throws Exception 可能抛出的异常.
*/
public static byte[] getSecretKey(long deptid) throws Exception {
byte[] key=null;
String value=null;
//CommDao =new CommDao();
// List list=.getRecordList("from Key k where k.deptid="+deptid);
//if(list.size()>0){
//value=((com.csc.sale.bean.Key)list.get(0)).getKey();
value = "CB7A92E3D3491964";
key=hexStringToByte(value);
//}
if (debug)
System.out.println("密钥:" + value);
return key;
}
public String encryptData2(String data) {
String en = null;
try {
byte[] key=hexStringToByte(this.key);
en = bytesToHexString(encryptData(data.getBytes(),key));
} catch (Exception e) {
e.printStackTrace();
}
return en;
}
public String decryptData2(String data) {
String de = null;
try {
byte[] key=hexStringToByte(this.key);
de = new String(decryptData(hexStringToByte(data),key));
} catch (Exception e) {
e.printStackTrace();
}
return de;
}
} 加密使用： byte[] key=Eryptogram.getSecretKey(deptid); //获得钥匙（字节数组）
byte[] tmp=Eryptogram.encryptData(password.getBytes(), key); //传入密码和钥匙，获得加密后的字节数组的密码
password=Eryptogram.bytesToHexString(tmp); //将字节数组转化为字符串，获得加密后的字符串密码解密与之差不多
I. 如何给rar压缩文件添加密码和注释
RAR 和 ZIP 两种格式均支持加密功能。
若要加密文件，在压缩之前你必须先指定密码，或直接在 压缩文件名和参数 对话框中指定。
在 命令行 模式时使用开关 -p[密码]。
而在 WinRAR 图形界面时，要输入密码你可以按下 Ctrl+P 或者是在 文件菜单 选择“设置默认密码”命令。
另一种方式是单击 WinRAR 窗口底部左下角的钥匙图标。在 压缩文件名和参数对话框 里的“高级选项”组中按下“设置密码”按钮输入密码。
和 ZIP 不同，RAR 格式不只允许数据，而且其它的可感知的压缩文件区域：文件名、大小、属性、注释和其它块都可加密。如果你希望这样做，你需要在密码对话框中设置“加密文件名” 选项，或在命令行模式使用 -p[密码] 的开关 -hp[密码]。以这种方式加密的文件，如果没有密码甚至不可能查看文件列表。
当不再需要的时候，别忘了将输入的密码删除。不然你或许又加密了别的压缩文件，但却不希望使用同一组密码。要删除密码时，只需要输入空字符串来替换原先的密码，或者先关闭 WinRAR 并重新启动一次。当有密码存在时，钥匙的图标是红色的，否则它是黄色的。而且，当你使用密码开始压缩操作时，标题栏 压缩文件名和参数对话框 也会闪烁两次。
如果你在 压缩文件名和参数 对话框直接输入它，你不需要删除密码。这不同于其它方式，此类密码仅在单一压缩操作有效，并在完成后它会自动删除。
当解压加密的文件时，开始操作之前你也可以不需要事先输入密码。如果 WinRAR 遇到加密的文件，而解压之前未先输入密码的话，它便会提示用户输入密码。
WinRAR 支持 ZIP 2.0 格式使用私有加密算法。 RAR 压缩文件使用更强大的 AES-128 标准加密。如果你需要加密重要的信息，选择 RAR 压缩文件格式会比较好一些。为了确实的安全性，密码长度请最少要 8 个字符。不要使用任何语言的单词作为密码，最好是任意的随机组合字符和数字，并且要注意密码的大小写。请记住，如果你遗失你的密码，你将无法取出加密的文件，就算是 WinRAR 的作者本身也无法解压加密过的文件。
J. 怎样用C语言编写简单加密程序
你就写个字符数组将字符存进数组，然后将数组的每个元素加4再赋值给自己就行了
例如
char a[3]={'a','b','c'};
for(i=0;i<3;i++)
a[i]+=4;
再输出数组元素就是加密后的了
谢谢采纳