算法实现: OTP(One-Time Pad) 一次一密密码本加解密

按照<<密码学导引>>上描述的OTP算法, 实现了一个OTP算法加解密工具~

src : srcOtpCipher_V2013_0111_0517.rar, 这版的明文只能是 'a'~'z', 以后会改成支持所有可见的Asiic字符.

src: srcOtpCihper_V2013_0111_2317.rar, 变形OTP算法, 支持可见Ascii字符集.

编译环境: win7X64Sp1 + vs2008Sp1

<2013_0111_2251>

将Cipher\Otp\OtpCipherConst.h 中的常量改了, 支持了可见Ascii字符集, 已经可以作为一个玩具使用.

从需求的变化到程序修改的实际效果中可以体会到宏的好处~

/// @file OtpCipherConst.h
/// @brief OtpCihper常量定义
#ifndef __OTP_CIPHER_CONST_H__
#define __OTP_CIPHER_CONST_H__
/// @ref http://www.dreamdu.com/xhtml/ascii/
/// 32 ~ 126 是可以打印的字符
#define OTP_FIRST_CHAR_W L' ' ///< 字符集中第一个字符
#define OTP_LAST_CHAR_W L'~' ///< 字符集中最后一个字符
#define OTP_FIRST_CHAR ' ' ///< 字符集中第一个字符
#define OTP_LAST_CHAR '~' ///< 字符集中最后一个字符
#define OTP_MOD (OTP_LAST_CHAR - OTP_FIRST_CHAR + 1)
#define OTP_FIRST_INDEX 1
#define OTP_LAST_INDEX OTP_MOD
#define SZ_FILE_NAME_PLAINTEXT L"OtpPlaintext.txt"
#define SZ_FILE_NAME_OTP_KEY L"OtpKey.txt"
#define SZ_FILE_NAME_CIPHERTEXT L"OtpCiphertext.txt"
/// 算法说明
#define SZ_ALG_README L"算法说明\r\n"\
L"OTP算法是一次一密的算法\r\n"\
L"变形的算法支持可见Ascii字符集\r\n"\
L"明文是' '~'~'的小写字母, 数组为x, 长度为N\r\n"\
L"密钥是' '~'~'的小写字母, 数组为k, 长度为N\r\n"\
L"OTP变形加密算法:\r\n"\
L"模M = '~' - ' '\r\n"\
L"EK(x) = ((x1 + k1)%M,(x2 + k2)%M,...(xn + kn)%M)\r\n"\
L"OTP解密算法:\r\n"\
L"DK(x) = ((x1 - k1)%M,(x2 - k2)%M,...(xn - kn)%M)\r\n"\
L"\r\n"\
L"变形后的OTP算法有效字符集为可见Ascii字符, 从' '~'~'\r\n"
#endif // #ifndef __OTP_CIPHER_CONST_H__

效果图

新的算法说明

<2013_0110>

算法说明:

OTP加密:

OTP解密:

从使用角度, 考虑了以下几点:

* 加密前的明文输入方式: 手工输入明文, 载入明文文件.

* 加密时的OTP密码自动生成.

* 加密后的文件保存(保存明文,密钥,密文).

* 解密前的密文输入方式: 手工输入密文, 载入密文文件.

* 解密前的密钥输入方式: 载入密钥文件.

* 解密后的文件保存(保存明文)

* 考虑到解密时,一般是直接使用密文和密钥文件, 而不会手工输入, 特别是密文较长时的情况.

/// @todo 原版OTP的明文内容只能是小写字母(a~z), 这不实用, 稍后要改成支持全部ascii字符,

/// 这样, 英文较好的使用者,就可以将这个工具作为一个实用工具.

直接按照书里描述的OTP算法, 解密不准确. 要处理一些细节.

e.g. 明文是'a', 密钥是'z', 加密和解密都要处理. 直接按照公式来行不通~

Otp加解密接口的实现如下:

/// @file OtpCipherConst.h
/// @brief OtpCihper常量定义
#ifndef __OTP_CIPHER_CONST_H__
#define __OTP_CIPHER_CONST_H__
#define OTP_FIRST_CHAR_W L'a' ///< 字符集中第一个字符
#define OTP_LAST_CHAR_W L'z' ///< 字符集中最后一个字符
#define OTP_FIRST_CHAR 'a' ///< 字符集中第一个字符
#define OTP_LAST_CHAR 'z' ///< 字符集中最后一个字符
#define OTP_MOD (OTP_LAST_CHAR - OTP_FIRST_CHAR + 1)
#define OTP_FIRST_INDEX 1
#define OTP_LAST_INDEX OTP_MOD
#define SZ_FILE_NAME_PLAINTEXT L"OtpPlaintext.txt"
#define SZ_FILE_NAME_OTP_KEY L"OtpKey.txt"
#define SZ_FILE_NAME_CIPHERTEXT L"OtpCiphertext.txt"
/// 算法说明
#define SZ_ALG_README L"算法说明\r\n"\
L"OTP算法是一次一密的算法\r\n"\
L"明文是a~z的小写字母, 数组为x, 长度为N\r\n"\
L"密钥是a~z的小写字母, 数组为k, 长度为N\r\n"\
L"OTP加密算法:\r\n"\
L"EK(x) = ((x1 + k1)%26,(x2 + k2)%26,...(xn + kn)%26)\r\n"\
L"OTP解密算法:\r\n"\
L"DK(x) = ((x1 - k1)%26,(x2 - k2)%26,...(xn - kn)%26)\r\n"
#endif // #ifndef __OTP_CIPHER_CONST_H__

/// @file OtpCipher.h
/// @brief OtpCihper函数定义
#ifndef __OTP_CIPHER_H__
#define __OTP_CIPHER_H__
#include "OtpCipherConst.h"
#include <tchar.h>
#include <string>
/// @fn isValidPlaintext
/// @brief 判断明文内容是否有效
/// @param IN const wchar_t * pcPlaintextW, 明文
/// @return boolen
/// @retval true, 明文有效
/// @retval false, 明文无效, 有非法字符
bool isValidPlaintext(IN const wchar_t * pcPlaintextW);
/// @fn isValidChar
/// @brief 给定的字符是否是有效的明文内容
/// @param IN char cIn, 给定的字符
/// @return boolen
/// @retval true, 入参字符有效
/// @retval false, 入参字符无效, 不是有效明文字符集中的字符
bool isValidChar(IN char cIn);
char char2Index(char cParam);
char Index2Char(char cParam);
char OtpModX(int iParam, char cMod);
/// @fn GenerateOtpKey
/// @brief 产生Otp密钥
/// @param IN const wchar_t * pcPlaintextW, 明文
/// @param OUT std::wstring & strOtpKeyW, 根据明文长度生成的等长度密钥
/// @return boolen
/// @retval true, 密钥产生成功
/// @retval false, 密钥产生失败
bool GenerateOtpKey(IN const wchar_t * pcPlaintextW, OUT std::wstring & strOtpKeyW);
/// @fn OtpCipher
/// @brief Otp加解密
/// @param IN bool bEncrypt, 是加密还是解密, true = 加密, false = 解密
/// @param IN OUT std::string & strPlaintext, 明文
/// @param IN const char * pcOtpKey, 密钥
/// @param IN OUT std::string & strCiphertext, 密文
bool OtpCipher(IN bool bEncrypt,
IN OUT std::string & strPlaintext,
IN const char * pcOtpKey,
IN OUT std::string & strCiphertext);
#endif // #ifndef __OTP_CIPHER_H__

/// @file OtpCipher.cpp
/// @brief OtpCihper函数实现
#include "stdafx.h"
#include "OtpCipher.h"
#include "Helper/string/stringHelper.h"
bool isValidPlaintext(IN const wchar_t * pcPlaintextW)
{
std::string strPlaintextA;
std::string::iterator it;
if(NULL == pcPlaintextW)
return false;
Wstring2String(strPlaintextA, pcPlaintextW);
for(it = strPlaintextA.begin(); it != strPlaintextA.end(); it++)
{
if(!isValidChar(*it))
return false;
}
return true;
}
bool isValidChar(IN char cIn)
{
return (cIn >= OTP_FIRST_CHAR) && (cIn <= OTP_LAST_CHAR);
}
bool GenerateOtpKey(IN const wchar_t * pcPlaintextW, OUT std::wstring & strOtpKeyW)
{
bool bPassFirstRand = true;
size_t nLen = 0;
wchar_t cRandW = '\0';
std::string strPlaintextA;
strOtpKeyW = L"";
if (NULL == pcPlaintextW)
return false;
srand(static_cast<UINT>(time(NULL)));
Wstring2String(strPlaintextA, pcPlaintextW);
nLen = strPlaintextA.length();
while (0 != nLen--)
{
cRandW = OTP_FIRST_CHAR_W - 1 + RangedRand(OTP_FIRST_INDEX, OTP_LAST_INDEX, bPassFirstRand);
bPassFirstRand = false;
strOtpKeyW += cRandW;
}
return true;
}
char char2Index(char cParam)
{
return cParam - OTP_FIRST_CHAR + 1;
}
char Index2Char(char cParam)
{
/// 字符集中最后一个字符的索引是0
return (cParam >= 1) ? (cParam - 1 + OTP_FIRST_CHAR) : OTP_LAST_CHAR;
}
char OtpModX(int iParam, char cMod)
{
if (iParam < 0)
iParam += cMod; ///< 防止 iParam < 0, e.g. ('a' - 'z') % 26
return static_cast<char>(iParam % cMod);
}
bool OtpCipher(IN bool bEncrypt,
IN OUT std::string & strPlaintext,
IN const char * pcOtpKey,
IN OUT std::string & strCiphertext)
{
char cTmp = '\0';
char cX = '\0';
char cK = '\0';
size_t nIndex = 0;
std::string::iterator it;
if ((NULL == pcOtpKey)
|| (bEncrypt && (strlen(strPlaintext.c_str()) != strlen(pcOtpKey)))
|| (!bEncrypt && (strlen(strCiphertext.c_str()) != strlen(pcOtpKey))))
{
return false;
}
if (bEncrypt)
{
/// OTP加密算法:
/// EK(x) = ((x1 + k1)%26,(x2 + k2)%26,...(xn + kn)%26)
strCiphertext = "";
for (it = strPlaintext.begin(); it != strPlaintext.end(); it++)
{
cX = char2Index(*it);
cK = char2Index(*(pcOtpKey + nIndex++));
cTmp = OtpModX(cX + cK, OTP_MOD);
strCiphertext += Index2Char(cTmp);
}
}
else
{
/// OTP解密算法:
/// DK(x) = ((x1 - k1)%26,(x2 - k2)%26,...(xn - kn)%26)
strPlaintext = "";
for (it = strCiphertext.begin(); it != strCiphertext.end(); it++)
{
cX = char2Index(*it);
cK = char2Index(*(pcOtpKey + nIndex++));
cTmp = OtpModX(cX - cK, OTP_MOD);
strPlaintext += Index2Char(cTmp);
}
}
return true;
}

<2013_0112_1033>

OTP加密的好处: 多表替换.

多表替换: 在整个消息中, 同一个字符通常不会被加密成同一个字符.

算法实现: OTP(One-Time Pad) 一次一密密码本 加解密

猜你喜欢

算法实现: OTP(One-Time Pad) 一次一密密码本加解密