密碼安全之密碼技術【2】替代密碼

密碼學

一門研究設計密碼算法和破譯密碼算法的綜合性技術科學，是網絡空間安全學科中理論體系最完善的一門科學，也是信息安全的基石。密碼學一般由密碼編碼和密碼分析兩大分支組成。

從密碼學的發展歷史來看，能夠分爲古典密碼學和現代密碼學。

古典密碼學

主要依靠人工計算和簡單的機械，而且以人的主觀意識來設計和應用。古典加密算法每每只是對單個的代替或置換操做。

現代密碼學…

1. 替代密碼

替代密碼的原理是使用替代法進行加密，就是將明文中的字符用其餘字符替代後造成密文，例如，明文字母a、b、c、d，用D、E、F、G作對應替換後造成密文。

替代密碼包括多種類型，如單表替代密碼，多明碼替代密碼，多字母替代密碼，多表替代密碼等

凱撒密碼

又稱循環移位密碼，是一種典型的單表替代密碼，它的加密方法就是將明文中的每一個字母用此字符在字母表中後面第k個字母替代，加密過程能夠表示爲：

E(m) = (m+k) mod n

【其中，m爲明文字母在字母表中的位置數，n爲字母表中的字母個數，k爲密鑰，E(m)爲密文字母在字母表中對應的位置數，mod n爲取模運算。】

因爲是對名文字母進行統一的偏移代替，所以密鑰極易被窮舉破解，爲了提升破解難度，多表代替密碼則是在加解密時使用了多個替換表，表明性算法有維吉尼亞密碼，希爾密碼，一次一密鑰密碼，Playfair密碼等。

維吉尼亞密碼

該密碼體制有一個參數 n ，在加解密時，一樣把英文字母映射爲 0~25 的數字再進行運算，並按 n 個字母一組進行變換。明文空間、密文空間及密鑰空間都是長度爲 n 的英文字母串的集合，加密體制描述以下：

加密變換定義爲：設密鑰 k = (k1,k2,...,kn),明文 m = (m1,m2,...,mn), 密文 c = (c1,c2,...,cn).
加密變換：Ek(m) = (c1,c2,...,cn), 其中，ci = (mi+ki) mod 26, i=1,2,...,n.
解密算法：Dk(m) = (m1,m2,...,mn), 其中，mi = (ci-ki) mod 26, i=1,2,...,n.

如下分別是對兩種加密方式的實現{後者包含了解密操做}【望指正】！！！

#include<iostream>
#include<map>
#include<string>
#define n 26
using namespace std;
template<typename _MapType>
auto get_map_key_value(const _MapType& input_map, const decltype(input_map.begin()->second)& mapped_value) -> decltype(input_map.begin()->first)
{
	auto iter = std::find_if(input_map.begin(), input_map.end(), [mapped_value](const auto& item) {
		return (item.second == mapped_value);
	});

	if (iter == input_map.end())
	{
		return decltype(input_map.begin()->first)();
	}
	return iter->first;
}
static map<char, int> Alphabetic_query = {
		{'a',1},{'b',2},{'c',3},{'d',4},
		{'e',5},{'f',6},{'g',7},{'h',8},
		{'i',9},{'j',10},{'k',11},{'l',12},
		{'m', 13},{'n',14},{'o',15},{'p',16},
		{'q',17},{'r',18},{'s',19}, {'t',20},
		{'u',21},{'v',22},{'w',23},{'x',24},
		{'y',25},{'z',26}
};
int  main() {
	cout << "THE FIRST METHOD CALLED Caesar PASSWORD" << endl;
	cout << "Enter the characters you need to encrypt and the key:";
	string characters,Enc_password;; char key, *position;
	int bridge_key, bridge_characters;
	cin >> characters >> key;
	if (characters.length() != NULL && key != NULL) {
		position = &characters[0];
		if (key >= 65 && key <= 90) bridge_key = Alphabetic_query.at(key + 32);
		else bridge_key = Alphabetic_query.at(key);
		while (position != NULL) {
			if ((*position) >= 65 && (*position) <= 90)
				bridge_characters = Alphabetic_query.at(*position + 32);
			else bridge_characters = Alphabetic_query.at(*position);
			
			Enc_password += Caesar(bridge_characters, bridge_key);
			position++;
		}
	}
	cout << "Encrypted character" << Enc_password << endl;
}
char Caesar(int m,int k) {
	return get_map_key_value(Alphabetic_query, (m + k) % n);
}

#include<iostream>
#include<map>
#include<string>
#define n 26
using namespace std;
template<typename _MapType>
auto get_map_key_value(const _MapType& input_map, const decltype(input_map.begin()->second)& mapped_value) -> decltype(input_map.begin()->first)
{
	auto iter = std::find_if(input_map.begin(), input_map.end(), [mapped_value](const auto& item) {
		return (item.second == mapped_value);
	});

	if (iter == input_map.end())
	{
		return decltype(input_map.begin()->first)();
	}
	return iter->first;
}
static map<char, int> Alphabetic_query = {
		{'a',1},{'b',2},{'c',3},{'d',4},
		{'e',5},{'f',6},{'g',7},{'h',8},
		{'i',9},{'j',10},{'k',11},{'l',12},
		{'m', 13},{'n',14},{'o',15},{'p',16},
		{'q',17},{'r',18},{'s',19}, {'t',20},
		{'u',21},{'v',22},{'w',23},{'x',24},
		{'y',25},{'z',26}
};
string characters, Enc_password, key; char *position_c, *position_k;
int bridge_key, bridge_characters;
bool flag;
int  main() {
	cout << "THE SECOND METHOD CALLED Virginia password" << endl;
	cout << "Enter the characters you need to encrypt and the key:";
	cin >> characters >> key;
	string result_e = Virginia_add(characters, key);
	cout << "Encrypted character" << result_e << endl;
	string result_u = Virginia_solution(result_e,key);
	cout << "Unencrypted character" << result_u << endl;
}
string transform(string &characters,string &key,bool flag) {
	if (characters.length() != NULL && key.length() != NULL && characters.length() == key.length()) {
		position_c = &characters[0];
		position_k = &key[0];
		while (position_c != NULL && position_k != NULL) {
			if (*position_k >= 65 && *position_k <= 90) bridge_key = Alphabetic_query.at(*position_k + 32);
			else bridge_key = Alphabetic_query.at(*position_k);
			if ((*position_c) >= 65 && (*position_c) <= 90) bridge_characters = Alphabetic_query.at(*position_c + 32);
			else bridge_characters = Alphabetic_query.at(*position_c);
			if(flag==true) Enc_password += Virginia(bridge_characters, bridge_key);
			else Enc_password += Virginia(bridge_characters, bridge_key);
			*position_c++; *position_k++;
		}
	}
	return Enc_password;
}
char Virginia(int m, int k) {
	return get_map_key_value(Alphabetic_query, (m + k) % n);
}
char Unvirginia(int m, int k) {
	return get_map_key_value(Alphabetic_query, (m - k) % n);
}
string Virginia_add(string &characters, string &key){
	return transform(characters, key,1);
}
string Virginia_solution(string &result,string &key) {
	return transform(result, key,0);
}