打败所有黑客 Beat All Hackers 加密算法 Encrypt

最新推荐文章于 2024-04-24 17:08:18 发布

creatorforum

最新推荐文章于 2024-04-24 17:08:18 发布

阅读量455

点赞数

文章标签：加密算法 textbox 解密破解 null

本文链接：https://blog.csdn.net/creatorforum/article/details/3503121

版权

打败所有黑客 Beat All Hackers

【欢迎转载或翻译该文】

现在上网，难免会涉及一些需要保密的内容，比如密码，账号，卡号，证件号等。但是黑客无处不在，他们常常窃听你的信息，给你放置陷阱，让你的防不胜防。

比如我现在要将信息“账号：123456，密码：567890” 从A经过B传递到C，黑客可能从中间环节B截取你传输的信息。我们日常交换的信息量是很大的，黑客怎么知道现在传输的就是“密码”或“账号”呢？那么他就会设定关键词，比如“密码”，凡是含有该关键词的信息都会被截获，而其他信息就会被放掉。

你可能会讲，你传输的信息都是通过加密的，对！这就是关键的地方，现在已经有很多加密算法，他们将我们传输的数据进行加密，但是请注意，既然可以加密就可以解密，你可能从网络上早已了解到，很多加密算法是如何的厉害，一台PC要暴利破解要多少年！可是你忽略了，黑客可能比你的计算机好，他也可能控制肉鸡帮他计算，他破解的速度可能远远超出你的想象。

同时，你必须注意，现在很多加密算法，加密部分都是掌握在别人手上，比如你通过及时通讯或email将信息传递给你的朋友，一般加密都是掌握在即时通讯提供方，和email提供方，如果被黑客利用，你的信息将视同于没有加密。或者黑客可以对其陷阱预设解密方法和密钥，一旦检测到就进行解密。所以你最好自己对信息加密！

现在问题是，黑客对你信息不能解密的放过，能够解密的再留下破解。你的信息仍然处于危险之中。于是有了我现在所说的这种加密方法，非函数不校检的加密方法。

加密思想：

原始文本：1234567890

密钥：123

首先如果密钥第一位为1，则将原始明文，逐位交换变成2143658709.

其次如果密钥第二位为2，则继续进行两两交换，变成4321876509

再次如果密钥第三位为3，则继续三三交换，变成1874326509

密钥是什么可以自己限定，交换方式也可以自己设定，你可以逐位交换，也可以跳转交换，也可以按密文所在位的值进行交换。主要思想就是，乱序。那么所有排列的数量就与你原始明文的长度密切相关，比如10位，所有可能就是P10的全排列。不同密码，可能加密出同样的结果。但是如果把一个字符按64位或256位处理，短短的10位字符，已经不再只有P10的全排列个结果。

关键点：不管你的计算机有多快，你每次只能解密一次！而且计算机不会告诉你是否解密正确，必须要你自己判断！即使黑客知道怎么解密也不好下手，即使他们做出所有的排列，也必须一个一个去判断哪一个正确。这是任何一个黑客都无法忍受的！而且排序很耗资源，即使其自定义一些检测方法也于事无补。

先看个例子：

原始明文“天上密密麻麻布满乌云，码头上的船也整整齐齐的排列在一起，等待暴风雨的来临！”

密码：235312336232

结果：“上密码天密麻满乌船的云布上暴列头风，齐齐，起麻整一的的在等排雨也来待整临！”

全句含标点37个字符，两个“密”一个“码”，现在只考虑一个“密”跟“码”结合组合成“密码”关键词，而且只考虑排在句首，那么组合形式就达P35的全排列。如果我们将这句话乱序发出，至少有P35/P37的概率触发黑客的“密码”关键词陷阱。打个比方就是，猎人在一条道上放了陷阱，凡是靠近地面行走的动物才会触发机关，现在是风吹一下就会触发机关。无穷的信息量将使黑客的陷阱充满无用信息，让其降低真正窃密的几率！

迫切性，大家都在说云计算时代来了，软件不用装了，海量信息可以存储到服务器上，走到哪里就在那里提取，但是你能保证你在服务器上的信息不泄露吗？怎么办？我的建议是，利用上面的加密思想进行加密，任何人想要暴利破解都不行，而你只需要输入密码，很快就可以确定那就是你的原始信息！

1，自己编译软件：首先如果你可以自己根据代码设置自己的算法（改变交换位置即可）和密码，然后自己编译成软件，那么加密方法就是你一个人独有的。

2, 添加浏览器插件：也可以为你的IE，Maxthon，firefox，opera等浏览器或其他工具添加插件。

这样你可以在发email或者写网上日志时使用。比如你想记录自己的日常生活，记在自己电脑上怕遗失，记在网上又怕被黑客攻击而泄露，所以这时你需要这个简单有效的加密方式，不增加内容的长度，看上去也跟别的日志没有区别，要看的时候，自己输入密码看就是，如果是IE等浏览器有插件设置好的话，还可以免去这些繁复的操作，自动加密和解密！

你的空间或博客可能设置有密码，如果你再通过这种方式对你写的日记加密，即使别人破解了你的空间密码，或博客出现漏洞，你的信息也不会被泄露。该方法也可以对文件和图片进行加密，比如图片，可以按照一个一个像素的交换，这样加密的图片是很难破解的，但是你根据你的密码可以轻松的还原。防止你的秘密相册被偷看。

这个当然也可以用于其他信息加密，比如声音加密，防止非法窃听！比如：语音有三个字“我爱你” 通过这种方式加密，可以变成“你爱我”。到底那个是正确的呢？一旦变长语句，你将无法得知，如果将音频数字化，更可以很好的保密。

C#编程外行，可能用的很不科学，特别是容错机制，但基本思想已经表达，代码还有很多bug，有建议的请跟帖到：sosecretblog.blogspot.com

利用该方法加密，然后再结合其他加密方式，比如AES，DES等，可以有效的保证你的数据安全！

 
    using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace NumberAntiHack
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        //----------Enumber Start----------- 
#region estring1------- 
        //-----estring1------------- 
        private string estring1(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                //-----COPY ori to after 
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
                //---transfer 1 by 1 
                for (int i = 1; i <= (len / 2); i++)
                {
                    int j = i * 2;
                    after[j - 2] = ori[j - 1];
                    after[j - 1] = ori[j - 2];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring1-------end---------- 
#endregion 
#region estring2------- 
        //-----estring2------------- 
        private string estring2(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
                //---transfer 2 by 2 
                for (int i = 1; i <= (len / 4); i++)
                {
                    int j = i * 4;
                    after[j - 2] = ori[j - 4];
                    after[j - 1] = ori[j - 3];
                    after[j - 4] = ori[j - 2];
                    after[j - 3] = ori[j - 1];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring2-------end---------- 
        #endregion 
#region estring3------- 
        //-----estring3------------- 
        private string estring3(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
//transfer 3 by 3 
                for (int i = 1; i <= (len / 6); i++)
                {
                    int j = i * 6;
                    after[j - 6] = ori[j - 3];
                    after[j - 5] = ori[j - 2];
                    after[j - 4] = ori[j - 1];
                    after[j - 3] = ori[j - 6];
                    after[j - 2] = ori[j - 5];
                    after[j - 1] = ori[j - 4];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring3-------end---------- 
        #endregion 
#region estring4------- 
        //-----estring4------------- 
        private string estring4(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
                //transfer 4 by 4 
                for (int i = 1; i <= (len / 8); i++)
                {
                    int j = i * 8;
                    after[j - 8] = ori[j - 4];
                    after[j - 7] = ori[j - 3];
                    after[j - 6] = ori[j - 2];
                    after[j - 5] = ori[j - 1];
                    after[j - 4] = ori[j - 8];
                    after[j - 3] = ori[j - 7];
                    after[j - 2] = ori[j - 6];
                    after[j - 1] = ori[j - 5];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring4-------end---------- 
        #endregion 
#region estring5------- 
        //-----estring5------------- 
        private string estring5(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
                //transfer 5 by 5 
                for (int i = 1; i <= (len / 10); i++)
                {
                    int j = i * 10;
                    after[j - 10] = ori[j - 5];
                    after[j - 9] = ori[j - 4];
                    after[j - 8] = ori[j - 3];
                    after[j - 7] = ori[j - 2];
                    after[j - 6] = ori[j - 1];
                    after[j - 5] = ori[j - 10];
                    after[j - 4] = ori[j - 9];
                    after[j - 3] = ori[j - 8];
                    after[j - 2] = ori[j - 7];
                    after[j - 1] = ori[j - 6];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring5-------end---------- 
        #endregion 
#region estring6------- 
        //-----estring6------------- 
        private string estring6(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
//transfrt 6 by 6 
                for (int i = 1; i <= (len / 12); i++)
                {
                    int j = i * 12;
                    after[j - 12] = ori[j - 6];
                    after[j - 11] = ori[j - 5];
                    after[j - 10] = ori[j - 4];
                    after[j - 9] = ori[j - 3];
                    after[j - 8] = ori[j - 2];
                    after[j - 7] = ori[j - 1];
                    after[j - 6] = ori[j - 12];
                    after[j - 5] = ori[j - 11];
                    after[j - 4] = ori[j - 10];
                    after[j - 3] = ori[j - 9];
                    after[j - 2] = ori[j - 8];
                    after[j - 1] = ori[j - 7];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring6-------end---------- 
        #endregion 
#region estring7------- 
        //-----estring7------------- 
        private string estring7(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
//transfer 7 by 7 
                for (int i = 1; i <= (len / 14); i++)
                {
                    int j = i * 14;
                    after[j - 14] = ori[j - 7];
                    after[j - 13] = ori[j - 6];
                    after[j - 12] = ori[j - 5];
                    after[j - 11] = ori[j - 4];
                    after[j - 10] = ori[j - 3];
                    after[j - 9] = ori[j - 2];
                    after[j - 8] = ori[j - 1];
                    after[j - 7] = ori[j - 14];
                    after[j - 6] = ori[j - 13];
                    after[j - 5] = ori[j - 12];
                    after[j - 4] = ori[j - 11];
                    after[j - 3] = ori[j - 10];
                    after[j - 2] = ori[j - 9];
                    after[j - 1] = ori[j - 8];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring7-------end---------- 
        #endregion 
#region estring8------- 
        //-----estring8------------- 
        private string estring8(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
//transfer 8 by 8 
                for (int i = 1; i <= (len / 16); i++)
                {
                    int j = i * 16;
                    after[j - 16] = ori[j - 8];
                    after[j - 15] = ori[j - 7];
                    after[j - 14] = ori[j - 6];
                    after[j - 13] = ori[j - 5];
                    after[j - 12] = ori[j - 4];
                    after[j - 11] = ori[j - 3];
                    after[j - 10] = ori[j - 2];
                    after[j - 9] = ori[j - 1];
                    after[j - 8] = ori[j - 16];
                    after[j - 7] = ori[j - 15];
                    after[j - 6] = ori[j - 14];
                    after[j - 5] = ori[j - 13];
                    after[j - 4] = ori[j - 12];
                    after[j - 3] = ori[j - 11];
                    after[j - 2] = ori[j - 10];
                    after[j - 1] = ori[j - 9];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring8-------end---------- 
        #endregion 
#region estring9------- 
        //-----estring9------------- 
        private string estring9(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
//transfer 9 by 9 
                for (int i = 1; i <= (len / 18); i++)
                {
                    int j = i * 18;
                    after[j - 18] = ori[j - 9];
                    after[j - 17] = ori[j - 8];
                    after[j - 16] = ori[j - 7];
                    after[j - 15] = ori[j - 6];
                    after[j - 14] = ori[j - 5];
                    after[j - 13] = ori[j - 4];
                    after[j - 12] = ori[j - 3];
                    after[j - 11] = ori[j - 2];
                    after[j - 10] = ori[j - 1];
                    after[j - 9] = ori[j - 18];
                    after[j - 8] = ori[j - 17];
                    after[j - 7] = ori[j - 16];
                    after[j - 6] = ori[j - 15];
                    after[j - 5] = ori[j - 14];
                    after[j - 4] = ori[j - 13];
                    after[j - 3] = ori[j - 12];
                    after[j - 2] = ori[j - 11];
                    after[j - 1] = ori[j - 10];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring9-------end---------- 
        #endregion 
#region estring0------- 
        //-----estring0------------- 
        private string estring0(string origin)
        {
            try
            {
                char[] ori = origin.ToCharArray();
                int len = ori.Length;
                char[] after = new char[len];
                for (int i = 0; i < len; i++)
                {
                    after[i] = ori[i];
                }
//transfer 10 by 10 
                for (int i = 1; i <= (len / 20); i++)
                {
                    int j = i * 20;
                    after[j - 20] = ori[j - 10];
                    after[j - 19] = ori[j - 9];
                    after[j - 18] = ori[j - 8];
                    after[j - 17] = ori[j - 7];
                    after[j - 16] = ori[j - 6];
                    after[j - 15] = ori[j - 5];
                    after[j - 14] = ori[j - 4];
                    after[j - 13] = ori[j - 3];
                    after[j - 12] = ori[j - 2];
                    after[j - 11] = ori[j - 1];
                    after[j - 10] = ori[j - 20];
                    after[j - 9] = ori[j - 19];
                    after[j - 8] = ori[j - 18];
                    after[j - 7] = ori[j - 17];
                    after[j - 6] = ori[j - 16];
                    after[j - 5] = ori[j - 15];
                    after[j - 4] = ori[j - 14];
                    after[j - 3] = ori[j - 13];
                    after[j - 2] = ori[j - 12];
                    after[j - 1] = ori[j - 11];
                }
                string last = new string(after);
                return last;
            }
            catch
            { return origin; }
        }
        //-----estring0-------end---------- 
        #endregion 
        //-------------------Enumber End------------- 
      
        private void button1_Click(object sender, EventArgs e)
        {
            if (textBox3 == null)
            {
                MessageBox.Show("No Password");
                              
            }
            else
            { if (textBox1 == null)
                {
                    MessageBox.Show("No words need to Encrypt");
                }
                else
                {
                    string key = textBox3.Text;
                    char[] keyword = key.ToCharArray();
                    int keylen = keyword.Length;
                    string origin = textBox1.Text;
                //---选择方法--- 
                    for (int i = 0; i < keylen; i++)
                    {
                                if (keyword [i]=='1')
                                   { origin =estring1(origin);}
                                else if(keyword [i]=='2')
                                   { origin =estring2(origin);}
                                else if (keyword[i] == '3')
                                   { origin  = estring3(origin);}
                                else if (keyword[i] == '4')
                                   { origin = estring4(origin); }
                                else if (keyword[i] == '5')
                                   { origin = estring5(origin); }
                                else if (keyword[i] == '6')
                                   { origin = estring6(origin); }
                                else if (keyword[i] == '7')
                                   { origin = estring7(origin); }
                                else if (keyword[i] == '8')
                                   { origin = estring8(origin); }
                                else if (keyword[i] == '9')
                                   { origin = estring9(origin); }
                                else if (keyword[i] == '0')
                                   { origin = estring0(origin); }
                                else
                                   { break; }
                       
                    }
                    string last = origin;
                    textBox2.Clear();
                    textBox2.AppendText(last);
                }; 
            }
        }
        private void Form1_Load(object sender, EventArgs e)
        {
        }
        private void textBox1_TextChanged(object sender, EventArgs e)
        {
        }
        private void textBox2_TextChanged(object sender, EventArgs e)
        {
        }
        private void textBox3_TextChanged(object sender, EventArgs e)
        {
        }
        private void button2_Click(object sender, EventArgs e)
        {
            if (textBox3 == null)
            {
                MessageBox.Show("No Password");
            }
            else
            {
                if (textBox1 == null)
                {
                    MessageBox.Show("No words need to Encrypt");
                }
                else
                {
                    string key = textBox3.Text;
                    char[] keyword = key.ToCharArray();
                    int keylen = keyword.Length;
                    string origin = textBox1.Text;
                    //---选择方法--- 
                    for (int i = keylen-1 ; i >= 0; i--)
                    {
                        if (keyword[i] == '1')
                        { origin = estring1(origin); }
                        else if (keyword[i] == '2')
                        { origin = estring2(origin); }
                        else if (keyword[i] == '3')
                        { origin = estring3(origin); }
                        else if (keyword[i] == '4')
                        { origin = estring4(origin); }
                        else if (keyword[i] == '5')
                        { origin = estring5(origin); }
                        else if (keyword[i] == '6')
                        { origin = estring6(origin); }
                        else if (keyword[i] == '7')
                        { origin = estring7(origin); }
                        else if (keyword[i] == '8')
                        { origin = estring8(origin); }
                        else if (keyword[i] == '9')
                        { origin = estring9(origin); }
                        else if (keyword[i] == '0')
                        { origin = estring0(origin); }
                        else
                        { break; }
                    }
                    string last = origin;
                    textBox2.Clear();
                    textBox2.AppendText(last);
                };
            }
        }
        private void button3_Click(object sender, EventArgs e)
        {
            if (textBox3 == null)
            {
                MessageBox.Show("No Password");
            }
            else
            {
                if (textBox1 == null)
                {
                    MessageBox.Show("No words need to Encrypt");
                }
                else
                {
                    string key = textBox3.Text;
                    char[] keyword = key.ToCharArray();
                    int keylen = keyword.Length;
                    //-----将输入字符串的二进制按字符串处理--- 
                    string ori1 = textBox1.Text;
                    char[] ori2 = ori1.ToCharArray();
                    byte[] ori3 = System.Text.Encoding.Default.GetBytes(ori2);
                    String origin = Convert .ToBase64String(ori3); 
                    //---选择方法--- 
                    for (int i = 0; i < keylen; i++)
                    {
                        if (keyword[i] == '1')
                        { origin = estring1(origin); }
                        else if (keyword[i] == '2')
                        { origin = estring2(origin); }
                        else if (keyword[i] == '3')
                        { origin = estring3(origin); }
                        else if (keyword[i] == '4')
                        { origin = estring4(origin); }
                        else if (keyword[i] == '5')
                        { origin = estring5(origin); }
                        else if (keyword[i] == '6')
                        { origin = estring6(origin); }
                        else if (keyword[i] == '7')
                        { origin = estring7(origin); }
                        else if (keyword[i] == '8')
                        { origin = estring8(origin); }
                        else if (keyword[i] == '9')
                        { origin = estring9(origin); }
                        else if (keyword[i] == '0')
                        { origin = estring0(origin); }
                        else
                        { break; }
                    }
                    string last = origin;
                    textBox2.Clear();
                    textBox2.AppendText(last);
                };
            }
        }
        private void button4_Click(object sender, EventArgs e)
        {
            if (textBox3 == null)
            {
                MessageBox.Show("No Password");
            }
            else
            {
                if (textBox1 == null)
                {
                    MessageBox.Show("No words need to Encrypt");
                }
                else
                {
                    string key = textBox3.Text;
                    char[] keyword = key.ToCharArray();
                    int keylen = keyword.Length;
                    //---将二进制转回---- 
                    string origin = textBox1.Text.ToString();
                    //---选择方法--- 
                    for (int i = keylen - 1; i >= 0; i--)
                    {
                        if (keyword[i] == '1')
                        { origin = estring1(origin); }
                        else if (keyword[i] == '2')
                        { origin = estring2(origin); }
                        else if (keyword[i] == '3')
                        { origin = estring3(origin); }
                        else if (keyword[i] == '4')
                        { origin = estring4(origin); }
                        else if (keyword[i] == '5')
                        { origin = estring5(origin); }
                        else if (keyword[i] == '6')
                        { origin = estring6(origin); }
                        else if (keyword[i] == '7')
                        { origin = estring7(origin); }
                        else if (keyword[i] == '8')
                        { origin = estring8(origin); }
                        else if (keyword[i] == '9')
                        { origin = estring9(origin); }
                        else if (keyword[i] == '0')
                        { origin = estring0(origin); }
                        else
                        { break; }
                    }
                    string last = origin;
                    byte[] last1 = Convert.FromBase64String(last);
                    char[] last2 = System.Text.Encoding.Default.GetChars(last1);
                    string last3 = new string(last2);
                    textBox2.Clear();
                    textBox2.AppendText(last3);
                };
            }
        }
        private void pictureBox1_Click(object sender, EventArgs e)
        {
            //--访问主页：http://www.sosecret.net 专注个人隐私保护 
            System.Diagnostics.Process.Start("http://www.sosecret.net");
        }
    }
}
 
   

挑战：有一个2万字符左右的加密文件，接受任何人的破解测试，论坛无法贴，请到blog留下联系方式，我将发送密文。

原始文件下载，请查看我的资源！

creatorforum

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
打败所有黑客 Beat All Hackers 加密算法 Encrypt

打败所有黑客 Beat All Hackers【欢迎转载或翻译该文】现在上网，难免会涉及一些需要保密的内容，比如密码，账号，卡号，证件号等。但是黑客无处不在，他们常常窃听你的信息，给你放置陷阱，让你的防不胜防。比如我现在要将信息“账号：123456，密码：567890” 从A经过B传递到C，黑客可能从中间环节B截取你传输的信息。我们日常交换的信息量是很大的，黑客怎么知道现在传输的
复制链接

扫一扫