精华内容
下载资源
问答
  • 包含三种基础的基于异或Xor的文件加密算法
  • c语言简单古典加密算法

    千次阅读 2019-03-25 22:57:11
    c语言仿射密码和维吉尼亚密码 仿射密码 // An highlighted block #include <stdio.h> int N=26; int exgcd(int a, int n) { int p = a, q = n; int x = 0, y = 1; int z = q / p; while (p != 1 &&...

    c语言仿射密码和维吉尼亚密码

    仿射密码

    // An highlighted block
    #include <stdio.h>
    int N=26;
    int exgcd(int a, int n) {
    	int p = a, q = n;
    	int x = 0, y = 1;
    	int z = q / p;
    	while (p != 1 && q != 1) {
    		int t = p;
    		p = q % p;
    		q = t;
    		t = y;
    		y = x - y * z;
    		x = t;
    		z = q / p;
    	}
    	y %= n;
    	if (y < 0) y += n;
    	return y;
    }
    void main()
    {   int a,b;
        char ch[1000];printf("输入明文");gets (ch);
    	printf("输入秘钥ab\n");
        scanf("%d",&a);
    	scanf("%d",&b);
    	d=exgcd(a,26);
    	int	i=0;
    	char re[1000];
    	
    	while (ch [i]!= '\0')
    	{
    		if ((int)ch [i]>= 65 && (int)ch[i] <= 90)//判断字符是否介于<A,Z>
    		{
    			re[i] = (char)(((a*((int)ch [i]- 65) + b) % N) + 65);
    			printf("%c",re[i]);
    		}
    		if ((int)ch [i]>= 97 && (int)ch [i]<= 122)//判断字符是否介于<a,z>
    		{
    			re[i] = (char)(((a*((int)ch [i]- 97) + b) % N) + 97);
    			printf("%c",re[i]);
    		}
    		else
    			i++;//若不是字母则不加处理
    		i++;
    	}
    	printf("\n");
    	i=0;
    	char ch1;
    while (re[i]!='\0')
    	{
    		if ((int)re[i] >= 65 && (int)re [i]<= 90)
    		{
    			ch1 = (char)(((d*(((int)re [i]- 65) - b)+N) % N) + 65);
    			printf("%c",ch1);
    		}
    		if ((int)re [i]>= 97 && (int)re [i]<= 122)
    		{
    			ch1 = (char)(((d*(((int)re [i]- 97) - b)+N) % N) + 97);
    			printf("%c",ch1);
    		}
    		else
    			i++;
    		i++;
    	}
    printf("\n");
    
    	
    
    	
    }
    
    
    
    

    维吉尼亚密码

    #include <stdio.h>
    #include <string.h>
    void main()
    {
    	char ch[1000],re[1000],key[1000],r;
    	int key1[1000],n=0,k,m;
    	int i=0;
    	printf("输入密文");
    	gets(ch);
    	printf("输入密钥");
    	gets(key);
    	while(key[i]!='\0')
    	{key1[i]=(int)key[i]-97;
         i++;
    	}
       int c=strlen(ch);
    //	printf("%d",c);printf("%d",i);
    	int j;
    	if(c%i>0)j=c/i+1;
    	else j=c/i;
    	//printf("%d",j);
    	for(k=0;k<j;k++)
    	{
    		for( m=0;m<i;m++)
    		{
    			if(ch[n]!='\0'){
    				re[n]=(((int)ch[n]-97+key1[m])%26+97)<=122 ? (char)(((int)ch[n]-97+key1[m])%26+97):(char)(((int)ch[n]-97+key1[m])%26+97-26);
    			printf("%c",re[n]);
    				n++;
    			}
    				
    			
    		}
    	}n=0;
    	printf("\n");
    	for(k=0;k<j;k++)
    	{
    		for(m=0;m<i;m++)
    		{
    			if(re[n]!='\0'){
    				r=(((int)re[n]-97-key1[m])%26+97)>=97?(char)(((int)re[n]-97-key1[m])%26+97):(char)(((int)re[n]-97-key1[m])%26+97+26);
    			printf("%c",r);
    				n++;
    			}
    				
    			
    		}
    	}
    
    }
    

    新人发表慢慢改进

    展开全文
  • 什么是维吉尼亚加密算法 加密步骤:1.创建一个匹配循环链表;2.接受需要加密的明文;3.根据随机生成的密钥配合链表进行移位;4.输出/保存对应的密文 解密步骤: 1.接受加密后的密钥;2.根据密文找到对应的匹配值...

    概念理解

    什么是维吉尼亚加密算法

    加密步骤:1.创建一个匹配循环链表;2.接受需要加密的明文;3.根据随机生成的密钥配合链表进行移位;4.输出/保存对应的密文

    解密步骤: 1.接受加密后的密钥;2.根据密文找到对应的匹配值,通过密钥进行逆移位操作找到明文输出

    总的来说维吉尼亚加密算法就是对循环链表的查找操作
    这里我们来模拟a-z实现加密操作

    在这里插入图片描述

    我们输入changlon,然后生成随机密钥,进行加密操作
    如:字符c,随机生成的密钥为2
    我们找到a-z循环链表中的c字符位置,向后查找2个单位指到e的位置,e就是对应c的密文
    注:图中的A-Z大写链表理解为a-z的小写链表,整个链表是循环的

    实现代码

    匹配链表结构定义

    //双向循环链表结构
    typedef struct doulNode{
    	char data;
    	struct doulNode *next;//指向下一个节点
    	struct doulNode *prior;	//指向上一个节点	
    }Doul,*DoulList;
    
    

    创建一个匹配链表

    //Status ,ok,error是宏定义int ,1,0
    Status createLink (DoulList *L){
    
    	(*L)=(DoulList)malloc(sizeof(Doul));
    	(*L)->next=(*L)->prior=NULL;//链表的头初始化
    	DoulList p,q;
    	p=(*L);
    	int i;
    	for(i=0;i<ALPHAS;i++){
    		q=(DoulList)malloc(sizeof(Doul));
    		q->data='a'+i;
    		q->next=p->next;
    		q->prior=p;
    		p->next=q;
    		p=q;
    	}
    	p->next=(*L)->next;
    	(*L)->next->prior=p;
    	p=(*L);
    	(*L)=p->next;
    	free(p);//释放头节点
    	
    	if((*L)->data=='a'){
    		return ok;	
    	}
    	
    	return error;
    }
    

    加密的实现代码

    Status encryption(DoulList L){
        	int index=0;
        	int i;
        	for(i=0;i<SIZE;i++) //清理缓存 
        		data[i]=0;
        		
    		printf("输入明文:");
    		scanf("%s",data);
    		printf("\n");	
    		srand(time(NULL));//设置一个随机种子
    		while(data[index]){
    			int secretKey=rand()%100+1;//生成随机密钥
    			int j; 
    			secret[index]=secretKey; 
    			//找到对应相同的的字符
    			 while(L->data!=data[index]){
    			 	L=L->next;
    			 }
    			 //进行移位
    			 for(j=0;j<secretKey;j++){
    			 	L=L->next;
    			 }
    			 
    			data[index]=L->data;	
    			printf("%c",data[index]);
    			index++;
    		}
    		return ok;
    }
    

    工程代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #define ok 1
    #define error 0
    #define ALPHAS 26 
    #define SIZE 100
    typedef int Status;
    typedef struct doulNode{
    	char data;
    	struct doulNode *next;
    	struct doulNode *prior;		
    }Doul,*DoulList;
    
    
    int secret[SIZE]={0};
    char data[SIZE]={0};
    
    Status createLink (DoulList *L);
    Status encryption(DoulList L);
    void checkSecretKey(void);
    
    int main(int argc, char *argv[]) {
    
    	DoulList L=NULL;
        int status=createLink (&L);
        if(status){
        	printf("-----------------------维吉尼亚加密算法---------------------------\n");
        	printf("\n");
        	printf("作者: changlon\n时间: 2019-12/17\n");
        	printf("\n");
    		printf("------------------------------------------------------------------\n");
        	
        	encryption(L);	
        	checkSecretKey();
    	}else{
    		printf("内存异常");
    	}
    	
    	printf("\n");
    	system("pause");
    	return 0;
    }
    
    void checkSecretKey(void){
    		int index=0;
    		printf("\n\n"); 
        	printf("你生成的密钥:");
    		while(secret[index]){
    			printf("%d ",secret[index++]);
    		}	
    }
    
    Status encryption(DoulList L){
        	int index=0;
        	int i;
        	for(i=0;i<SIZE;i++) //清理缓存 
        		data[i]=0;
        		
    		printf("输入明文:");
    		scanf("%s",data);
    		printf("\n");	
    		srand(time(NULL));
    		while(data[index]){
    			int secretKey=rand()%100+1;
    			int j; 
    			secret[index]=secretKey; 
    			 while(L->data!=data[index]){
    			 	L=L->next;
    			 }
    			 for(j=0;j<secretKey;j++){
    			 	L=L->next;
    			 }
    			 
    			data[index]=L->data;	
    			printf("%c",data[index]);
    			index++;
    		}
    		return ok;
    }
    
    Status createLink (DoulList *L){
    
    	(*L)=(DoulList)malloc(sizeof(Doul));
    	(*L)->next=(*L)->prior=NULL;
    	DoulList p,q;
    	p=(*L);
    	int i;
    	for(i=0;i<ALPHAS;i++){
    		q=(DoulList)malloc(sizeof(Doul));
    		q->data='a'+i;
    		q->next=p->next;
    		q->prior=p;
    		p->next=q;
    		p=q;
    	}
    	p->next=(*L)->next;
    	(*L)->next->prior=p;
    	p=(*L);
    	(*L)=p->next;
    	free(p);
    	if((*L)->data=='a'){
    		return ok;	
    	}
    	
    	return error;
    }
    
    
    
    
    展开全文
  • 这是一个基于c语言的AES加密算法,相对来说比较简单,供大家参考。
  • 题目:在C语言下如何交换2个变量 条件不添加第3个临时变量 说实话面试的时候被问到这样操蛋的题目真的很蛋疼, (本人从来不刷面试题) 如图 总结后我思考出这不就是...后期继续跟进学习加密算法,哈希算法、sha256 ...

    题目:在C语言下如何交换2个变量

    条件不添加第3个临时变量

    说实话面试的时候被问到这样操蛋的题目真的很蛋疼, (本人从来不刷面试题)

    如图
    在这里插入图片描述
    总结后我思考出这不就是可以运用到对称加密 和 非对称加密(公钥、私钥)的问题嘛。后期继续跟进学习加密算法,哈希算法、sha256

    展开全文
  • 加密算法有很多,我在网上找了个简单的算法,可惜是C语言的, 朕很不满意 ,一怒之下,自己研究了研究,改造成了java的; 后来安卓和ios都需要统一后台加密,手机端解密,经过简化和进一步的研究,增加了java和OC的...

    加密算法有很多,我在网上找了个简单的算法,可惜是C语言的, 朕很不满意 ,一怒之下,自己研究了研究,改造成了java的;

    后来ios端也需要解密后台加密的数据,所以,又把算法简化了一下,作成了java和OC通用的加密算法。现在分享给大家。希望对大家有所帮助

    java的加密小demo

    public class MainTest {
    
        public static void main(String[] args) {
              String text="8952262wsdf wef vew 885";//需要加密的字符串
              int key=1314;//key
              String jiami=Encrypt(text,key);//加密
             System.out.println("密文:"+jiami);
    
              String jiemi=Decrypt(jiami,key);//解密
              System.out.println("原文文:"+jiemi);
    
        }
    
        private static int C1= 52845;
        private static int C2= 22719;
    
        // 加密函数
    
        public static String Encrypt(String S, int Key) 
        {
    
            StringBuffer Result=new StringBuffer();
            StringBuffer str;
         int i,j;
    
    
         for(i=0; i<S.length(); i++){
             // 依次对字符串中各字符进行操作
             Result.append((char)(S.charAt(i)^(Key>>8))); // 将密钥移位后与字符异或
             Key = ((byte)Result.charAt(i)+Key)*C1+C2; // 产生下一个密钥
         }
         S=Result.toString();
         System.out.println("密文中间值:"+S);
         Result=new StringBuffer();
         for(i=0; i<S.length(); i++) // 对加密结果进行转换
         {
          j=(int)S.charAt(i); // 提取字符
          // 将字符转换为两个字母保存
          str=new StringBuffer(); // 设置str长度为2
          str.append((char)(65+j/26));//这里将65改大点的数例如256,密文就会变乱码,效果更好,相应的,解密处要改为相同的数
          str.append((char)(65+j%26));
          Result.append(str);
         }
         return Result.toString();
        }
    
        // 解密函数
    
        public static String Decrypt(String S, int Key) 
        {
            StringBuffer Result=new StringBuffer();
            StringBuffer str;
         int i,j;
    
    
         for(i=0; i < S.length()/2; i++) // 将字符串两个字母一组进行处理
         {
          j = ((int)S.charAt(2*i)-65)*26;//相应的,解密处要改为相同的数
    
          j += (int)S.charAt(2*i+1)-65;
          Result.append((char)j);
         }
         S=Result.toString(); // 保存中间结果
         System.out.println("原文中间值:"+S);
         Result=new StringBuffer();
         for(i=0; i<S.length(); i++) // 依次对字符串中各字符进行操作
         {
          Result.append((char)(S.charAt(i)^(Key>>8))); // 将密钥移位后与字符异或
          Key = ((byte)S.charAt(i)+Key)*C1+C2; // 产生下一个密钥
         }
         return Result.toString();
        }
    
    }
    

    原来的C/C++的加密demo

    基于vc6 :
    
    
    
    // 常量
    #define C1 52845
    #define C2 22719
    
    
    CString Encrypt(CString S, WORD Key) // 加密函数
    {
     CString Result,str;
     int i,j;
    
     Result=S; // 初始化结果字符串
     for(i=0; i<S.GetLength(); i++) // 依次对字符串中各字符进行操作
     {
      Result.SetAt(i, S.GetAt(i)^(Key>>8)); // 将密钥移位后与字符异或
      Key = ((BYTE)Result.GetAt(i)+Key)*C1+C2; // 产生下一个密钥
     }
     S=Result; // 保存结果
     Result.Empty(); // 清除结果
     for(i=0; i<S.GetLength(); i++) // 对加密结果进行转换
     {
      j=(BYTE)S.GetAt(i); // 提取字符
      // 将字符转换为两个字母保存
      str="12"; // 设置str长度为2
      str.SetAt(0, 65+j/26);//这里将65改大点的数例如256,密文就会变乱码,效果更好,相应的,解密处要改为相同的数
      str.SetAt(1, 65+j%26);
      Result += str;
     }
     return Result;
    }
    
    // 解密函数
    
    CString Decrypt(CString S, WORD Key) 
    {
     CString Result,str;
     int i,j;
    
     Result.Empty(); // 清除结果
     for(i=0; i < S.GetLength()/2; i++) // 将字符串两个字母一组进行处理
     {
      j = ((BYTE)S.GetAt(2*i)-65)*26;//相应的,解密处要改为相同的数
    
      j += (BYTE)S.GetAt(2*i+1)-65;
      str="1"; // 设置str长度为1
      str.SetAt(0, j);
      Result+=str; // 追加字符,还原字符串
     }
     S=Result; // 保存中间结果
     for(i=0; i<S.GetLength(); i++) // 依次对字符串中各字符进行操作
     {
      Result.SetAt(i, (BYTE)S.GetAt(i)^(Key>>8)); // 将密钥移位后与字符异或
      Key = ((BYTE)S.GetAt(i)+Key)*C1+C2; // 产生下一个密钥
     }
     return Result;
    }
    
    
    
    //实际应用
    
    xxx()
    
    {
    
        CString text=_T("abc_@#%#$^$^ $");//需要加密的字符串
     WORD key=1314;//key
     CString jiami=Encrypt(text,key);//加密
     AfxMessageBox(_T("密文:")+jiami);
    
     CString jiemi=Decrypt(jiami,key);//解密
     AfxMessageBox(_T("原文:")+jiemi);
    
    }


    简化后的java与oc通用的加密算法

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStreamReader;
    import java.io.UnsupportedEncodingException;
    import java.math.BigInteger;
    import java.nio.ByteBuffer;
    import java.text.SimpleDateFormat;
    import java.util.Base64;
    import java.util.Date;
    
    import org.bouncycastle.math.ec.ECPoint;
    
    import org.junit.Test;
    
    
    public  class test {
          private  int C1 = 520;
          private  int C2 = 1314;
        @Test
        public  void test() {
                String text="zhangys";//需要加密的字符串
                System.out.println("原文:"+text);
                int key=20171001;//key
    
                String jiami=Encrypt(text,key);//加密
    
                System.out.println("密文:"+jiami);
    
                String jiemi=Decrypt(jiami,key);//解密
    
                System.out.println("原文文:"+jiemi);
    
            }
    
    
    
        /**
         *    加密函数
          */
        public  String Encrypt(String S, int Key) {
    
            ByteBuffer buffer=ByteBuffer.allocate(S.length()*2);
    
            for (int i = 0; i < S.length(); i++) {
                // 依次对字符串中各字符进行操作
    
                char c=(char)((S.charAt(i)) ^ (Key >> 8));
                System.out.println(i+"c: "+(int)c);
                byte[] b=charToByte(c);
    
                buffer.put(b);
    
                Key = (Key>>8) * C1 + C2; // 产生下一个密钥
            }
           // System.out.println(buffer.);
            buffer.flip();  
            // 构建一个byte数组  
            byte[] content = new byte[buffer.limit()];  
            // 从ByteBuffer中读取数据到byte数组中  
            buffer.get(content);  
    
            // 把byte数组的内容写到标准输出  
            System.out.println(bytesToHexString(content)); 
    
            return   new String(Base64.getEncoder().encodeToString(content));
    
        }
    
        /**
         *  解密函数
          */
    
    
        public  String Decrypt(String S, int Key) {
            StringBuffer Result = new StringBuffer();
            byte[] content;
            try {
                content=Base64.getDecoder().decode(S.getBytes("UTF-8"));
            } catch (UnsupportedEncodingException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                return "";
            }
            System.out.println("content: "+bytesToHexString(content));
            for (int i = 0; i < content.length/2; i++) // 依次对字符串中各字符进行操作
            {
                byte [] b={content[i*2],content[i*2+1]};
                char c=byteToChar(b);
    
                System.out.println(i+"c: "+(int)c);
                Result.append((char)( c ^ (Key >> 8))); // 将密钥移位后与字符异或
    
    
                Key = (Key>>8) * C1 + C2; // 产生下一个密钥;
            }
            return Result.toString();
        }
    
    
        //char转化为byte:
    
        public byte[] charToByte(char c) {
            byte[] b = new byte[2];
            b[0] = (byte) ((c & 0xFF00)>> 8);
            b[1] = (byte) (c & 0xFF);
            return b;
        }
    
    
    
    
        //byte转换为char:
        public char byteToChar(byte[] b) {
            char c = (char) (((b[0] & 0xFF)<< 8) | (b[1] &0xFF));       
            return c;
        }
    
        public  String bytesToHexString(byte[] data, int start, int end) {
            StringBuilder sb = new StringBuilder("");
            if(data == null) {
                return "";
            } else {
                end = Math.min(end, data.length);
    
                for(int index = start; index < end; ++index) {
                    int v = data[index] & 255;
                    String hv = Integer.toHexString(v);
                    if(hv.length() < 2) {
                        sb.append(0);
                    }
    
                    sb.append(hv.toLowerCase());
                }
    
                return sb.toString();
            }
        }
    
        public  String bytesToHexString(byte[] data) {
            return data == null?"":bytesToHexString(data, 0, data.length);
        }
    
    
    }

    日志输出:
    原文:zhangys
    0c: 13234
    1c: 29019
    2c: 62869
    3c: 5106
    4c: 30653
    5c: 37646
    6c: 29693
    33b2715bf59513f277bd930e73fd
    密文:M7JxW/WVE/J3vZMOc/0=
    content: 33b2715bf59513f277bd930e73fd
    0c: 13234
    1c: 29019
    2c: 62869
    3c: 5106
    4c: 30653
    5c: 37646
    6c: 29693
    原文文:zhangys

    oc ios端的加密解密

    //
    //  SecretUtils.m
    //  SecondApp
    //
    //  Created by localuser on 2017/10/10.
    //  Copyright © 2017年 localuser. All rights reserved.
    
    #include <string.h>
    #import "SecretUtils.h"
    #define  C1 520
    #define  C2 1314
    
    @implementation SecretUtils
    
    //加密函数
    +(NSString *)Encrypt:( NSMutableString *)S withKey:(int)Key{
    
        Byte byteEncrypt[[S length]*2];
    
        for(int i=0; i<[S length]; i++) // 依次对字符串中各字符进行操作
        {
            unichar c=[S characterAtIndex:i]^(Key>>8);
    
    //        NSLog(@"c: %d",(int)c);
            Byte b[2];
            b[0]=(Byte)((c&0xFF00)>>8);
            b[1]=(Byte)(c&0xFF);
            //[self IntToBytes:c with:b];
            byteEncrypt[i*2]=b[0];
            byteEncrypt[i*2+1]=b[1];
    //        NSLog(@"%d b[0]:%d  b[1]:%d",i,b[0],b[1]);
    
    
           Key = (Key>>8)*C1+C2; // 产生下一个密钥
        }
    
    
    
        NSData *plainData = [NSData dataWithBytes:byteEncrypt length:sizeof(byteEncrypt)/sizeof(char)];
    
        NSString *base64String = [plainData base64EncodedStringWithOptions:0];
    
        return base64String;
    }
    
    
    //解密函数
    +(NSString *)Decrypt:(NSString *)S withKey:(int)Key{
        NSMutableString *Result=[[NSMutableString alloc]init];
    
        NSData *decodedData = [[NSData alloc] initWithBase64EncodedString:S options:0];
    
        //Byte *content=(Byte *)[decodedData bytes];
        //int length= strlen(content)/2;
    
        NSUInteger len = [decodedData length];
        Byte *content = (Byte*)malloc(len);
        memcpy(content, [decodedData bytes], len);
    
        int length= len/2;
        for(int i=0; i<length; i++) // 依次对字符串中各字符进行操作
        {
            Byte b[2]={content[2*i],content[2*i+1]};
            unichar c= (unichar)(((b[0]& 0xff)<<8)| (b[1]&0xff));
    
    //         NSLog(@"jiemi c: %d",c);
    //         NSLog(@"%d b[0]: %d  b[1]:%d",i,content[2*i],content[2*i+1]);
    
            [Result appendString:[NSString stringWithFormat:@"%c", c^(Key>>8)]];
    
            Key = (Key>>8)*C1+C2;
        }
        return Result;
    }
    
    
    @end
     //test
        int key=20171001;
    
        NSString * s=[SecretUtils Encrypt:@"zhangys" withKey:key];
    
        NSLog(@"密文为: %@",s);
        NSString * s1=[SecretUtils Decrypt:s withKey:key];
        NSLog(@"明文为: %@",s1);

    主要日志
    2017-10-12 15:56:11. 密文为: M7JxW/WVE/J3vZMOc/0=
    2017-10-12 15:56:11. 明文为: zhangys

    这里java和oc的密文加密结果一致。而且都能单独加密和解密,相互加密和解密。总算是没白忙活。

    展开全文
  • AES加密算法c语言实现代码

    热门讨论 2012-05-17 11:29:42
    AES加密算法c语言实现代码,详细,简单,很容易看懂
  • 原文地址::... 相关文章 1、 md5加密算法c语言版 ----http://blog.chinaunix.net/uid-24118190-id-4372129.html 2、md5加密算法的C代码实现 ----http://blog.chinaunix.net/uid-2
  • AEC 加密算法(c语言)

    2018-12-11 17:00:26
    这是用C编写的AES ECB,CTR和CBC加密算法的小型便携式实现。 您可以通过定义符号AES192或AES256来覆盖默认密钥大小128位192或256位aes.h,(API很简单,看起来像这样(我使用的是C99 风格的注释类型)
  • 加密主要是通过一种算法对原内容进行处理,使原来内容不直观可见。解密过程通常要知道加密的算法,然后对加密后的...加密算法: 大(小)写字母加密后还为大(小)写字母。大(小)写字母向后推 n 位,n 由用户输入,
  • DES加密算法C语言实现,有详细的描述和算法解析,适合初次接触加密算法的菜鸟,简单明了
  • des加密算法,程序中输入密钥和和明文后密文的地方可以改用文件输入这样,比较简单,这里我没有实现。
  • C语言文字加密程序的实现

    万次阅读 多人点赞 2018-10-01 22:43:41
    下面就给大家提供一个原理极其简单程序极其容易实现的C语言文字加密小程序的实现算法。 原理:ASCLL码的加减乘除运算。举一个最简单的例子,从键盘输入一行字符"LANGUAGE",将所有字符的ASCLL码加1后再...
  • 最近学了点加密算法于是打算自己写一个小程序来实现这些加解密过程。先从简单的背包加密开始吧。
  • 1.首先加上一些库:apt-getinstallopenssllibssl-devlibssl-doclibcurl4...2.实现一个用MD5加密密码的小程序: #include<stdio.h> #include<stdlib.h> #include<string.h> #include<openss...
  • //#include "stdafx.h"#include string.h>#include stdio.h>#define MAX 256#define KEY 17 //密钥char cipher(char sourceChar, int Key) //加密算法...{ return (sourceChar 
  • C语言,看着简单,写着也还好,但就是真正写程序的时候出现莫名其妙的错误,感觉自己没有错,可偏偏就是运行出错。 写程序最痛苦的不是有very very 多的错误,而是我根本不知道错误在哪里。 高级语言和C语言相比,...
  • 经过多年的测试和分析,美国政府选择了Keccak算法作为SHA - 3的加密标准,现在我们分析一下它的工作原理以及使用方法。 2012年10月,美国NIST选择了Keccak算法作为SHA - 3的标准算法,Keccak拥有良好的加密性能以及...
  • 写完了带有cbc的背包加密,按照课程,接下来应该学RSA,限于码力不足,仍然选用一个字符对应一个数字的加密方法,再加上cbc扩散提高加密强度。
  • md5加密算法源码,c语言源码

    热门讨论 2010-06-30 17:50:31
    md5加密算法源码: 一 \md5加密是对字符或密码进行的16位或32位等加密方式! 一般在普通MDB数据库经常用到,比如论坛数据库等.有用! 二 \加密解密并不矛盾,比如银行系统的128位加密现在谁可以轻易破的了呢? 虽然md5...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 211
精华内容 84
关键字:

c语言简单加密算法

c语言 订阅