自定义构建加密算法（混合加密）-yiteyi-C++库

密码学可以定义为对模式（以消息的形式）进行编码和解码的艺术。

密码学是一个非常简单的概念，它处理的是操纵字符串（或文本），使中间人无法读取它们。它有一个非常有效的方法 加密或解密 文本来自其他各方。其中的一些例子有凯撒密码、维格纳密码、柱状密码、DES、AES，下面的列表继续。为了开发自定义加密算法，可以使用混合加密算法。

null

混合加密是密码学中的一个概念，它结合/合并一个/两个加密算法来生成更有效的加密文本。

例子：

FibBil密码算法

问题陈述：

程序生成加密文本，通过计算斐波那契级数，将斐波那契级数的项与每个明文字母相加，直到密钥的长度。

算法：

对于加密： 从用户处获取输入的纯文本和键，反转纯文本并将纯文本与键连接，将字符串复制到数组中。复制后，将数组元素分为两部分：EvenArray和OddArray，其中数组的偶数索引将被放置在EvenArray中，OddArray的偶数索引将被放置在其中。开始生成斐波那契级数F（i），直到键的长度 _J 以至于 c=i+j 其中c是mod 26的密文。附加所有的c ^th 元素，这样加密就完成了！。当总结的概念是使用，它强调了实施凯撒密码。

对于解密： 反之亦然的加密算法

算法示例：

输入： 你好 关键： abcd 输出： riobkxezg 反转输入，olleh，用键追加，即ollehabcd。 EvenString:leac 奇怪的字符串：olhbd 由于密钥长度为4，将生成4次循环，包括忽略的FibNum 0。 对于数组密码： FibNum:1 在l和FibNum的偶数数组中，cip是k 在e和FibNum 1的偶数数组中，cip是d 在a的偶数数组中，FibNum 1的cip是z 在c和FibNum 1的偶数数组中，cip是b FibNum:2 在l和FibNum 2的偶数数组中，cip是j 在e和FibNum 2的偶数数组中，cip是c 在a和FibNum 2的偶数数组中，cip为y 在c和FibNum 2的偶数数组中，cip是一个 FibNum:3 （最终计算字母） 在l和FibNum 3的偶数数组中，cip是i 在e和FibNum 3的偶数数组中，cip是b 在a和FibNum 3的偶数数组中，cip是x 在c和FibNum 3的偶数数组中，cip是z 对于奇数数组密码 菲布纳姆： 1. 在o和FibNum的奇数数组中，cip是p 在l和FibNum的奇数数组中，cip是m 在奇数数组中，对于h和FibNum 1，cip是i 在b和FibNum 1的奇数数组中，cip是c 在d和FibNum的奇数数组中，cip是e 菲布纳姆： 2. 在o和FibNum 2的奇数数组中，cip是q 在l和FibNum 2的奇数数组中，cip是n 在奇数数组中，对于h和FibNum 2，cip是j 在b和FibNum 2的奇数数组中，cip是d 在d和FibNum 2的奇数数组中，cip是f 菲布纳姆： 3（最终计算字母） 在o和FibNum 3的奇数数组中，cip是r 在l和FibNum 3的奇数数组中，cip是o 在奇数数组中，对于h和FibNum 3，cip是k 在b和FibNum 3的奇数数组中，cip是e 在d和FibNum 3的奇数数组中，cip是g

按索引顺序排列EvenArrayiPhone和OddArrayiPhone，这样最终的字符串密码将是， riobkxezg

节目：

C++14

                         #include<bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         string encryptText(string password, string key)                       
                         {                       
                                                 int                                     a = 0, b = 1, c = 0,                       
                                                 m = 0, k = 0, j = 0;                       
                                                 string cipher =                                     ""                                     , temp =                                     ""                                     ;                       
           
                                                 // Declare a password string                       
                                                 string pw = password;                       
           
                                                 // Reverse the String                       
                                                 reverse(pw.begin(), pw.end());                       
                                                 pw = pw + key;                       
           
                                                 // For future Purpose                       
                                                 temp = pw;                       
                                                 string stringArray = temp;                       
                                                 string evenString =                                     ""                                     , oddString =                                     ""                                     ;                       
           
                                                 // Declare EvenArray for storing                       
                                                 // even index of stringArray                       
                                                 string evenArray;                       
           
                                                 // Declare OddArray for storing                       
                                                 // odd index of stringArray                       
                                                 string oddArray;                       
           
                                                 // Storing the positions in their                       
                                                 // respective arrays                       
                                                 for                                     (                                     int                                     i = 0;                       
                                                 i < stringArray.length(); i++)                       
                                                 {                       
                                                 if                                     (i % 2 == 0)                       
                                                 {                       
                                                 oddString = oddString +                       
                                                 stringArray[i];                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 evenString = evenString +                       
                                                 stringArray[i];                       
                                                 }                       
                                                 }                       
           
                                                 evenArray =                                     new                                     char                                     [evenString.length()];                       
                                                 oddArray =                                     new                                     char                                     [oddString.length()];                       
           
                                                 // Generate a Fibonacci Series                       
                                                 // Upto the Key Length                       
                                                 while                                     (m <= key.length())                       
                                                 {                       
                                   
                                                 // As it always starts with 1                       
                                                 if                                     (m == 0)                       
                                                 m = 1;                       
           
                                                 else                       
                                                 {                       
                                   
                                                 // Logic For Fibonacci Series                       
                                                 a = b;                       
                                                 b = c;                       
                                                 c = a + b;                       
                                   
                                                 for                                     (                                     int                                     i = 0;                       
                                                 i < evenString.length();                       
                                                 i++)                       
                                                 {                       
                                   
                                                 // Caesar Cipher Algorithm Start                       
                                                 // for even positions                       
                                                 int                                     p = evenString[i];                       
                                                 int                                     cip = 0;                       
                                   
                                                 if                                     (p ==                                     '0'                                     || p ==                                     '1'                                     ||                       
                                                 p ==                                     '2'                                     || p ==                                     '3'                                     ||                       
                                                 p ==                                     '4'                                     || p ==                                     '5'                                     ||                       
                                                 p ==                                     '6'                                     || p ==                                     '7'                                     ||                       
                                                 p ==                                     '8'                                     || p ==                                     '9'                                     )                       
                                                 {                       
                                                 cip = p - c;                       
                                   
                                                 if                                     (cip <                                     '0'                                     )                       
                                                 cip = cip + 9;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 cip = p - c;                       
                                                 if                                     (cip <                                     'a'                                     )                       
                                                 {                       
                                                 cip = cip + 26;                       
                                                 }                       
                                                 }                       
                                                 evenArray[i] = (                                     char                                     )cip;                       
                                   
                                                 // Caesar Cipher Algorithm End                       
                                                 }                       
                                                 for                                     (                                     int                                     i = 0;                       
                                                 i < oddString.length();                       
                                                 i++)                       
                                                 {                       
                                   
                                                 // Caesar Cipher Algorithm                       
                                                 // Start for odd positions                       
                                                 int                                     p = oddString[i];                       
                                                 int                                     cip = 0;                       
                                   
                                                 if                                     (p ==                                     '0'                                     || p ==                                     '1'                                     ||                       
                                                 p ==                                     '2'                                     || p ==                                     '3'                                     ||                       
                                                 p ==                                     '4'                                     || p ==                                     '5'                                     ||                       
                                                 p ==                                     '6'                                     || p ==                                     '7'                                     ||                       
                                                 p ==                                     '8'                                     || p ==                                     '9'                                     )                       
                                                 {                       
                                                 cip = p + c;                       
                                                 if                                     (cip >                                     '9'                                     )                       
                                                 cip = cip - 9;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 cip = p + c;                       
                                                 if                                     (cip >                                     'z'                                     )                       
                                                 {                       
                                                 cip = cip - 26;                       
                                                 }                       
                                                 }                       
                                                 oddArray[i] = (                                     char                                     )cip;                       
                                   
                                                 // Caesar Cipher Algorithm End                       
                                                 }                       
                                                 m++;                       
                                                 }                       
                                                 }                       
           
                                                 // Storing content of even and                       
                                                 // odd array to the string array                       
                                                 for                                     (                                     int                                     i = 0; i < stringArray.size(); i++)                       
                                                 {                       
                                                 if                                     (i % 2 == 0)                       
                                                 {                       
                                                 stringArray[i] = oddArray[k];                       
                                                 k++;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 stringArray[i] = evenArray[j];                       
                                                 j++;                       
                                                 }                       
                                                 }                       
                                   
                                                 // Generating a Cipher Text                       
                                                 // by stringArray (Caesar Cipher)                       
                                                 for                                     (                                     char                                     d : stringArray)                       
                                                 {                       
                                                 cipher = cipher + d;                       
                                                 }                       
                                   
                                                 // Return the Cipher Text                       
                                                 return                                     cipher;                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 string pass =                                     "hello"                                     ;                       
                                                 string key =                                     "abcd"                                     ;                       
                                   
                                                 cout << encryptText(pass, key);                       
           
                                                 return                                     0;                       
                         }                       
           
                         // This code is contributed by himanshu77                       

JAVA

                         import                                     java.util.*;                       
                         import                                     java.lang.*;                       
           
                         class                                     GFG {                       
           
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 String pass =                                     "hello"                                     ;                       
                                                 String key =                                     "abcd"                                     ;                       
                                                 System.out.println(encryptText(pass, key));                       
                                                 }                       
                                                 public                                     static                                     String encryptText(String password, String key)                       
                                                 {                       
                                                 int                                     a =                                     0                                     , b =                                     1                                     , c =                                     0                                     , m =                                     0                                     , k =                                     0                                     , j =                                     0                                     ;                       
                                                 String cipher =                                     ""                                     , temp =                                     ""                                     ;                       
           
                                                 // Declare a password string                       
                                                 StringBuffer pw =                                     new                                     StringBuffer(password);                       
           
                                                 // Reverse the String                       
                                                 pw = pw.reverse();                       
                                                 pw = pw.append(key);                       
           
                                                 // For future Purpose                       
                                                 temp = pw.toString();                       
                                                 char                                     stringArray[] = temp.toCharArray();                       
                                                 String evenString =                                     ""                                     , oddString =                                     ""                                     ;                       
           
                                                 // Declare EvenArray for storing                       
                                                 // even index of stringArray                       
                                                 char                                     evenArray[];                       
           
                                                 // Declare OddArray for storing                       
                                                 // odd index of stringArray                       
                                                 char                                     oddArray[];                       
           
                                                 // Storing the positions in their respective arrays                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < stringArray.length; i++) {                       
                                                 if                                     (i %                                     2                                     ==                                     0                                     ) {                       
                                                 oddString = oddString + Character.toString(stringArray[i]);                       
                                                 }                       
                                                 else                                     {                       
                                                 evenString = evenString + Character.toString(stringArray[i]);                       
                                                 }                       
                                                 }                       
                                                 evenArray =                                     new                                     char                                     [evenString.length()];                       
                                                 oddArray =                                     new                                     char                                     [oddString.length()];                       
           
                                                 // Generate a Fibonacci Series                       
                                                 // Upto the Key Length                       
                                                 while                                     (m <= key.length()) {                       
                                                 // As it always starts with 1                       
                                                 if                                     (m ==                                     0                                     )                       
                                                 m =                                     1                                     ;                       
           
                                                 else                                     {                       
           
                                                 // Logic For Fibonacci Series                       
                                                 a = b;                       
                                                 b = c;                       
                                                 c = a + b;                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < evenString.length(); i++) {                       
                                                 // Caesar Cipher Algorithm Start for even positions                       
                                                 int                                     p = evenString.charAt(i);                       
                                                 int                                     cip =                                     0                                     ;                       
                                                 if                                     (p ==                                     '0'                                     || p ==                                     '1'                                     || p ==                                     '2'                                     || p ==                                     '3'                                     || p ==                                     '4'                       
                                                 || p ==                                     '5'                                     || p ==                                     '6'                       
                                                 || p ==                                     '7'                                     || p ==                                     '8'                                     || p ==                                     '9'                                     ) {                       
                                                 cip = p - c;                       
                                                 if                                     (cip <                                     '0'                                     )                       
                                                 cip = cip +                                     9                                     ;                       
                                                 }                       
                                                 else                                     {                       
                                                 cip = p - c;                       
                                                 if                                     (cip <                                     'a'                                     ) {                       
                                                 cip = cip +                                     26                                     ;                       
                                                 }                       
                                                 }                       
                                                 evenArray[i] = (                                     char                                     )cip;                       
                                                 /* Caesar Cipher Algorithm End*/                       
                                                 }                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < oddString.length(); i++) {                       
                                                 // Caesar Cipher Algorithm Start for odd positions                       
                                                 int                                     p = oddString.charAt(i);                       
                                                 int                                     cip =                                     0                                     ;                       
                                                 if                                     (p ==                                     '0'                                     || p ==                                     '1'                                     || p ==                                     '2'                                     || p ==                                     '3'                                     || p ==                                     '4'                       
                                                 || p ==                                     '5'                                     || p ==                                     '6'                       
                                                 || p ==                                     '7'                                     || p ==                                     '8'                                     || p ==                                     '9'                                     ) {                       
                                                 cip = p + c;                       
                                                 if                                     (cip >                                     '9'                                     )                       
                                                 cip = cip -                                     9                                     ;                       
                                                 }                       
                                                 else                                     {                       
                                                 cip = p + c;                       
                                                 if                                     (cip >                                     'z'                                     ) {                       
                                                 cip = cip -                                     26                                     ;                       
                                                 }                       
                                                 }                       
                                                 oddArray[i] = (                                     char                                     )cip;                       
                                                 // Caesar Cipher Algorithm End                       
                                                 }                       
           
                                                 m++;                       
                                                 }                       
                                                 }                       
           
                                                 // Storing content of even and                       
                                                 // odd array to the string array                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < stringArray.length; i++) {                       
                                                 if                                     (i %                                     2                                     ==                                     0                                     ) {                       
                                                 stringArray[i] = oddArray[k];                       
                                                 k++;                       
                                                 }                       
                                                 else                                     {                       
                                                 stringArray[i] = evenArray[j];                       
                                                 j++;                       
                                                 }                       
                                                 }                       
                                                 // Generating a Cipher Text                       
                                                 // by stringArray (Caesar Cipher)                       
                                                 for                                     (                                     char                                     d : stringArray) {                       
                                                 cipher = cipher + d;                       
                                                 }                       
           
                                                 // Return the Cipher Text                       
                                                 return                                     cipher;                       
                                                 }                       
                         }                       

输出：

riobkxezg

结论：

混合密码算法是有效的，因此，不太容易检测模式和解码消息。在这里，该算法是数学函数和凯撒密码的结合，从而实现了混合密码算法。

文章版权归作者所有，未经允许请勿转载。

THE END

Java