命令行文件加密工具源码

最新推荐文章于 2024-09-07 09:49:17 发布
最新推荐文章于 2024-09-07 09:49:17 发布
阅读量1k 收藏
点赞数
分类专栏： 算法研究 文章标签： 加密 工具 null dst buffer header
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tttx/article/details/5337339
版权

程序使用RC5算法对文件内容进行加密，同时加密文件名，加密后的文件名和文件签名一起进行Base64编码，最后生成一个加密名称作为新的文件名，只有输入正确密码才能查看文件名和文件内容。

命令行参数介绍

加密文件：-e -k key -i filename [-t directory] [-p prefix]
例：encrypt.exe -e -k 123456 test.txt C:/encrypt_file/

解密文件：-d -k key -i filename [-t directory]
例：encrypt.exe -d -k 123456 kml_811jW7BCsRZ2oIeqvqc=.rwz C:/decrypt_file/

校对文件：-c -k key -i filename1 -i filename2
例：encrypt.exe -c -k 123456 -i test.txt -i kml_811jW7BCsRZ2oIeqvqc=.rwz

列出指定目录下的加密文件：-l -k key [-t directory]
例：encrypt.exe -l -k 123456 -t C:/encrypt_file/
输出： 列出 C:/encrypt_file/ 下的加密文件
文件名                 长度       加密文件名
====================   ========   ============================================
test.txt               920.00B    kml_811jW7BCsRZ2oIeqvqc=.rwz
共找到 1 个加密文件

 

 

#include <windows.h>
#include <stdio.h>

#define RC5_R 12
#define RC5_P 0xb7e15163
#define RC5_Q 0x9e3779b9
#define ROTL(x, c) (((x) << ((c) & 31)) | ((x) >> (32 - ((c) & 31))))
#define ROTR(x, c) (((x) >> ((c) & 31)) | ((x) << (32 - ((c) & 31))))

#define MAX_FILENAME 140
#define FILE_ENCRYPT_SIGNATURE '/xe7ZWR'

typedef unsigned char UCHAR;
typedef unsigned short USHORT;
typedef unsigned long ULONG;

typedef struct _FILE_ENCRYPT_HEADER
{
 union
 {
  ULONG dwSignature;
  struct
  {
   USHORT wSignature;
   USHORT cCheckCode : 14;
   USHORT cCheckValue : 2;
  };
 };
 ULONG dwFirstEncrypt : 4;
 ULONG dwSecondEncrypt : 4;
 ULONG dwReserved : 8;
 ULONG dwJunkFill : 16;
 char cFileName[];
} FILE_ENCRYPT_HEADER, *PFILE_ENCRYPT_HEADER;

static ULONG rc5_sbox[RC5_R * 2 + 2];
static char base64_alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
static int base64_table_empty = 1;
static UCHAR base64_table[256];

ULONG Base64Encode(void *dst, void *src, ULONG len)
{
 UCHAR *p1 = src;
 char *p2 = dst;
 ULONG i, v;

 for (i = 0; i < len; i += 3)
 {
  switch (len - i)
  {
  case 1:
   v = (p1[i] << 16);
   *p2++ = base64_alphabet[v >> 18];
   *p2++ = base64_alphabet[(v >> 12) & 63];
   *p2++ = base64_alphabet[64];
   *p2++ = base64_alphabet[64];
   break;

  case 2:
   v = (p1[i] << 16) | (p1[i + 1] << 8);
   *p2++ = base64_alphabet[v >> 18];
   *p2++ = base64_alphabet[(v >> 12) & 63];
   *p2++ = base64_alphabet[(v >> 6) & 63];
   *p2++ = base64_alphabet[64];
   break;

  default:
   v = (p1[i] << 16) | (p1[i + 1] << 8) | p1[i + 2];
   *p2++ = base64_alphabet[v >> 18];
   *p2++ = base64_alphabet[(v >> 12) & 63];
   *p2++ = base64_alphabet[(v >> 6) & 63];
   *p2++ = base64_alphabet[v & 63];
   break;
  }
 }

 *p2++ = '/0';

 return p2 - (char *)dst;
}

ULONG Base64Decode(void *dst, void *src,ULONG len)
{
 char *p1 = src;
 UCHAR *p2 = dst;
 ULONG i, v, n;

 if (base64_table_empty)
 {
  for (i = 0; i < sizeof(base64_table); i++)
   base64_table[i] = 255;

  for (i = 0; i < 64; i++)
   base64_table[base64_alphabet[i]] = (char)i;

  base64_table_empty = 0;
 }

 for (i = 0, n = 0; i < len; i++)
 {
  if (base64_table[p1[i]] == 255)
   break;

  v = base64_table[p1[i]] | (v << 6);
  n += 6;

  if (n >= 8)
  {
   n -= 8;
   *p2++ = (UCHAR)(v >> n);
  }
 }

 return p2 - (UCHAR *)dst;
}

void rc5_key(UCHAR *pbKey, ULONG dwLen)
{
 ULONG i, j, k, A, B;
 ULONG *S;
 ULONG L[16];
 ULONG SL, LL;

 SL = (RC5_R + 1) * 2;
 LL = (dwLen + 3) >> 2;
 S = rc5_sbox;
 L[dwLen >> 2] = 0;
 memcpy((UCHAR *)L, pbKey, dwLen);

 S[0] = RC5_P;

 for (i = 1; i < SL; i++)
 {
  S[i] = S[i - 1] + RC5_Q;
 }

 i = (SL > LL ? SL : LL) * 3;
 A = B = j = k = 0;

 for (; i > 0; i--)
 {
  A = S[j] = ROTL(S[j] + (A + B), 3);
  B = L[k] = ROTL(L[k] + (A + B), (A + B));
  if (++j >= SL) j = 0;
  if (++k >= LL) k = 0;
 }
}

static void rc5_encrypt1(UCHAR *pOut, UCHAR *pIn)
{
 ULONG i, A, B;
 ULONG *S;

 S = rc5_sbox;
 A = ((ULONG *)pIn)[0] + S[0];
 B = ((ULONG *)pIn)[1] + S[1];

 for (i = 1; i <= RC5_R; i++)
 {
  A = ROTL(A ^ B, B) + S[2 * i];
  B = ROTL(B ^ A, A) + S[2 * i + 1];
 }

 ((ULONG *)pOut)[0] = A;
 ((ULONG *)pOut)[1] = B;
}

static void rc5_decrypt1(UCHAR *pOut, UCHAR *pIn)
{
 ULONG i, A, B;
 ULONG *S;

 S = rc5_sbox;
 B = ((ULONG *)pIn)[1];
 A = ((ULONG *)pIn)[0];

 for (i = RC5_R; i > 0; i--)
 {
  B = ROTR(B - S[2 * i + 1], A) ^ A;
  A = ROTR(A - S[2 * i], B) ^ B;
 }

 ((ULONG *)pOut)[1] = B - S[1];
 ((ULONG *)pOut)[0] = A - S[0];
}

void rc5_encrypt(void *dst, void *src, ULONG len)
{
 ULONG i, m, n;

 if (len < 8)
 {
  for (i = 0; i < len; i++)
   ((UCHAR *)dst)[i] = ((UCHAR *)src)[i] ^ (UCHAR)rc5_sbox[i];
  return;
 }

 if (len & 7)
 {
  n = (len & 7) + 8;
  m = len - n;
 }
 else
 {
  n = 0;
  m = len;
 }

 for (i = 0; i < m; i += 8)
 {
  rc5_encrypt1((UCHAR *)dst + i, (UCHAR *)src + i);
 }

 if (n)
 {
  memcpy((UCHAR *)dst + i, (UCHAR *)src + i, n);
  rc5_encrypt1((UCHAR *)dst + i, (UCHAR *)dst + i);
  rc5_encrypt1((UCHAR *)dst + i + n - 8, (UCHAR *)dst + i + n - 8);
 }
}

void rc5_decrypt(void *dst, void *src, ULONG len)
{
 ULONG i, m, n;

 if (len < 8)
 {
  for (i = 0; i < len; i++)
   ((UCHAR *)dst)[i] = ((UCHAR *)src)[i] ^ (UCHAR)rc5_sbox[i];
  return;
 }

 if (len & 7)
 {
  n = (len & 7) + 8;
  m = len - n;
 }
 else
 {
  n = 0;
  m = len;
 }

 for (i = 0; i < m; i += 8)
 {
  rc5_decrypt1((UCHAR *)dst + i, (UCHAR *)src + i);
 }

 if (n)
 {
  memcpy((UCHAR *)dst + i, (UCHAR *)src + i, n);
  rc5_decrypt1((UCHAR *)dst + i + n - 8, (UCHAR *)dst + i + n - 8);
  rc5_decrypt1((UCHAR *)dst + i, (UCHAR *)dst + i);
 }
}

void Replace(char *lpStr, int ch1, int ch2)
{
 int i, l = strlen(lpStr);

 for (i = 0; i < l; i++)
 {
  if (lpStr[i] == (char)ch1)
   lpStr[i] = (char)ch2;
 }
}

int ProcessFile(char *lpSrcFile, char *lpDstFile, int type)
{
 HANDLE hSrcFile, hDstFile;
 ULONG i, j, nFileSize, nBlockSize;
 ULONG nReadBytes, nWriteBytes;
 UCHAR buf[0x10000];

 hSrcFile = CreateFile(lpSrcFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

 if (hSrcFile == INVALID_HANDLE_VALUE)
 {
  printf("创建文件 %s 失败，错误码： %d/n", lpSrcFile, GetLastError());
  return -1;
 }

 nFileSize = GetFileSize(hSrcFile, NULL);

 if (nFileSize == -1)
 {
  CloseHandle(hSrcFile);
  printf("GetFileSize 失败，错误码： %d/n", GetLastError());
  return -1;
 }

 hDstFile = CreateFile(lpDstFile, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL);

 if (hDstFile == INVALID_HANDLE_VALUE)
 {
  CloseHandle(hSrcFile);
  printf("创建文件 %s 失败，错误码： %d/n", lpDstFile, GetLastError());
  return -1;
 }

 if (SetFilePointer(hDstFile, nFileSize, NULL, FILE_BEGIN) == -1)
  goto failed;

 if (!SetEndOfFile(hDstFile))
  goto failed;

 SetFilePointer(hDstFile, 0, NULL, FILE_BEGIN);

 for (i = 0; i < nFileSize; i += nBlockSize)
 {
  nBlockSize = min(nFileSize - i, sizeof(buf));

  for (j = 0; j < nBlockSize; j += nReadBytes)
  {
   if (!ReadFile(hSrcFile, buf + j, nBlockSize - j, &nReadBytes, NULL))
    goto failed;
  }

  switch (type)
  {
  case 1:
   rc5_encrypt(buf, buf, nBlockSize);
   break;
  case 2:
   rc5_decrypt(buf, buf, nBlockSize);
   break;
  }

  for (j = 0; j < nBlockSize; j += nWriteBytes)
  {
   if (!WriteFile(hDstFile, buf + j, nBlockSize - j, &nWriteBytes, NULL))
    goto failed;
  }

  printf("/r已完成 %2d%%", i / (nFileSize / 100));
 }

 printf("/r写入文件完成/n");

 CloseHandle(hSrcFile);
 CloseHandle(hDstFile);

 return 0;

failed:
 printf("/r写入文件失败/n");

 CloseHandle(hSrcFile);
 CloseHandle(hDstFile);
 DeleteFile(lpDstFile);

 return -1;
}

int DoFileEncrypt(char *lpFileName, char *lpOutDir, char *pPrefix)
{
 char szNewFile[MAX_PATH];
 char szPartName[MAX_PATH];
 char szOutFile[MAX_PATH];
 char buffer[200];
 int nNameLength;
 PFILE_ENCRYPT_HEADER feh;

 feh = (PFILE_ENCRYPT_HEADER)szNewFile;
 strcpy(szPartName, strrchr(lpFileName, '//') + 1);

 if (strlen(szPartName) > MAX_FILENAME)
 {
  printf("%s 文件名太长，最大文件名长度 %d/n", lpFileName, MAX_FILENAME);
  return -1;
 }

 srand(GetTickCount());

 strcpy(feh->cFileName, szPartName);
 feh->wSignature = 0xa3b5;
 feh->cCheckValue = (USHORT)rand();
 feh->cCheckCode = feh->cCheckValue ^ 0x77;
 feh->dwFirstEncrypt = 1;
 feh->dwSecondEncrypt = 0;
 feh->dwReserved = 0;
 feh->dwJunkFill = rand() & 0x7fff;

 nNameLength = sizeof(FILE_ENCRYPT_HEADER) + strlen(szPartName) + 1;
 rc5_encrypt(buffer, szNewFile, nNameLength);
 Base64Encode(szNewFile, buffer, nNameLength);
 Replace(szNewFile, '/', '_');

 if (pPrefix != NULL)
  sprintf(szOutFile, "%s//%s-%s.rwz", lpOutDir, pPrefix, szNewFile);
 else
  sprintf(szOutFile, "%s//%s.rwz", lpOutDir, szNewFile);

 printf("开始加密 %s 到 %s/n", lpFileName, szOutFile);

 return ProcessFile(lpFileName, szOutFile, 1);
}

int DoFileDecrypt(char *lpFileName, char *lpOutDir)
{
 char szPartName[MAX_PATH];
 char szOutFile[MAX_PATH];
 char buffer[200];
 int nNameLength;
 PFILE_ENCRYPT_HEADER feh;
 char *pExtName;

 feh = (PFILE_ENCRYPT_HEADER)buffer;
 strcpy(szPartName, strrchr(lpFileName, '//') + 1);
 Replace(szPartName, '_', '/');

 pExtName = strrchr(szPartName, '-');

 if (pExtName != NULL)
 {
  strcpy(szPartName, pExtName + 1);
 }

 pExtName = strrchr(szPartName, '.');

 if (pExtName != NULL)
 {
  *pExtName = '/0';
 }

 if (strlen(szPartName) < 12)
 {
  printf("%s 文件名信息不正确/n", szPartName);
  return -1;
 }

 nNameLength = Base64Decode(buffer, szPartName, -1);
 rc5_decrypt(buffer, buffer, nNameLength);

 if (feh->dwSignature != FILE_ENCRYPT_SIGNATURE)
 {
  if (feh->wSignature != 0xa3b5 || feh->cCheckValue != (feh->cCheckCode ^ 0x77))
  {
   printf("%s 文件签名失配，密码错误？/n", szPartName);
   return -1;
  }
 }

 sprintf(szOutFile, "%s//%s", lpOutDir, feh->cFileName);
 printf("开始解密 %s 到 %s/n", lpFileName, szOutFile);

 return ProcessFile(lpFileName, szOutFile, 2);
}

int DoCheckFile(char *lpFileName1, char *lpFileName2)
{
 HANDLE hSrcFile, hDstFile;
 ULONG i, j, nFileSize, nBlockSize;
 ULONG nReadBytes;
 UCHAR buf1[0x10000], buf2[0x10000];

 printf("开始校对文件：源 %s 目标 %s/n", lpFileName1, lpFileName2);

 hSrcFile = CreateFile(lpFileName1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

 if (hSrcFile == INVALID_HANDLE_VALUE)
 {
  printf("打开文件 %s 失败，错误码： %d/n", lpFileName1, GetLastError());
  return -1;
 }

 nFileSize = GetFileSize(hSrcFile, NULL);

 if (nFileSize == -1)
 {
  CloseHandle(hSrcFile);
  printf("GetFileSize 失败，错误码： %d/n", GetLastError());
  return -1;
 }

 hDstFile = CreateFile(lpFileName2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

 if (hDstFile == INVALID_HANDLE_VALUE)
 {
  CloseHandle(hSrcFile);
  printf("打开文件 %s 失败，错误码： %d/n", lpFileName2, GetLastError());
  return -1;
 }

 if (nFileSize != GetFileSize(hDstFile, NULL))
 {
  printf("校对失败，文件长度不一致/n");
  goto failed;
 }

 for (i = 0; i < nFileSize; i += nBlockSize)
 {
  nBlockSize = min(nFileSize - i, sizeof(buf1));

  for (j = 0; j < nBlockSize; j += nReadBytes)
  {
   if (!ReadFile(hSrcFile, buf1 + j, nBlockSize - j, &nReadBytes, NULL))
   {
    printf("读取文件失败，错误码 %d/n", GetLastError());
    goto failed;
   }
  }

  for (j = 0; j < nBlockSize; j += nReadBytes)
  {
   if (!ReadFile(hDstFile, buf2 + j, nBlockSize - j, &nReadBytes, NULL))
   {
    printf("读取文件失败，错误码 %d/n", GetLastError());
    goto failed;
   }
  }

  rc5_decrypt(buf1, buf1, nBlockSize);

  if (memcmp(buf1, buf2, nBlockSize) != 0)
  {
   printf("校对失败，文件内容不一致/n");
   goto failed;
  }

  printf("/r已完成 %2d%%", i / (nFileSize / 100));
 }

 printf("/r校对文件完成/n");

failed:
 CloseHandle(hSrcFile);
 CloseHandle(hDstFile);

 return 0;
}

int DoListFile(char *lpDirPath)
{
 WIN32_FIND_DATA wfd;
 HANDLE hFind;
 char szFind[MAX_PATH];
 char szPartName[MAX_PATH];
 char buffer[200];
 PFILE_ENCRYPT_HEADER feh;
 int nNameLength;
 char *pExtName;
 double nFileLength;
 char szFileLength[60];
 int nFileCount = 0;

 printf(" 列出 %s 下的加密文件/n", lpDirPath);
 printf("文件名                 长度       加密文件名/n");
 printf("====================   ========   ============================================/n");
 sprintf(szFind, "%s//*.rwz", lpDirPath);
 feh = (PFILE_ENCRYPT_HEADER)buffer;
 hFind = FindFirstFile(szFind, &wfd);

 if (hFind == INVALID_HANDLE_VALUE)
 {
  return 0;
 }

 do
 {
  if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
  {
   if (wfd.cFileName[0] == '.' && (*(short *)(wfd.cFileName + 1) == '.' || !wfd.cFileName[1]))
    continue;
  }

  strcpy(szPartName, wfd.cFileName);
  Replace(szPartName, '_', '/');
  pExtName = strrchr(szPartName, '-');

  if (pExtName != NULL)
  {
   strcpy(szPartName, pExtName + 1);
  }

  pExtName = strrchr(szPartName, '.');

  if (pExtName != NULL)
  {
   *pExtName = '/0';
  }

  if (strlen(szPartName) < 12)
   continue;

  nNameLength = Base64Decode(buffer, szPartName, -1);
  rc5_decrypt(buffer, buffer, nNameLength);

  if (feh->dwSignature != FILE_ENCRYPT_SIGNATURE)
  {
   if (feh->wSignature != 0xa3b5 || feh->cCheckValue != (feh->cCheckCode ^ 0x77))
    continue;
  }

  nFileLength = wfd.nFileSizeLow;

  if (nFileLength > 1000 * 1000 * 1000)
  {
   nFileLength /= 1024 * 1024 * 1024;
   sprintf(szFileLength, "%3.2fGB", nFileLength);
  }
  if (nFileLength > 1000 * 1000)
  {
   nFileLength /= 1024 * 1024;
   sprintf(szFileLength, "%3.2fMB", nFileLength);
  }
  else if (nFileLength > 1000)
  {
   nFileLength /= 1024;
   sprintf(szFileLength, "%3.2fKB", nFileLength);
  }
  else
  {
   sprintf(szFileLength, "%3.2fB ", nFileLength);
  }

  printf("%-20.20s   %8.8s   %-44.44s/n", feh->cFileName, szFileLength, wfd.cFileName);
  nFileCount++;
 } while (FindNextFile(hFind, &wfd));

 printf("共找到 %d 个加密文件/n", nFileCount);

 FindClose(hFind);

 return 0;
}

void usage(char *lpAppName)
{
 printf("加密文件：%s -e -k key -i filename [-t directory] [-p prefix]/n", lpAppName);
 printf("解密文件：%s -d -k key -i filename [-t directory]/n", lpAppName);
 printf("校对文件：%s -c -k key -i filename1 -i filename2/n", lpAppName);
 printf("列出指定目录下的加密文件：%s -l -k key [-t directory]/n", lpAppName);
}

int main(int argc, char *argv[])
{
 char szInputFile[MAX_PATH] = {0};
 char szTargetDir[MAX_PATH] = {0};
 char *pPrefix = NULL;
 int i;

 if (argc < 4)
 {
  usage(argv[0]);
  return -1;
 }

 if (argc == 4)
 {
  rc5_key(argv[1], strlen(argv[1]));
  ProcessFile(argv[2], argv[3], 2);
  return 0;
 }

 if (stricmp(argv[2], "-k") != 0)
 {
  usage(argv[0]);
  return -1;
 }

 rc5_key(argv[3], strlen(argv[3]));

 if (stricmp(argv[1], "-e") == 0)
 {
  if (argc < 6)
  {
   usage(argv[0]);
   return -1;
  }

  if (stricmp(argv[4], "-i") != 0)
  {
   usage(argv[0]);
   return -1;
  }

  GetFullPathName(argv[5], sizeof(szInputFile), szInputFile, NULL);

  if (argc > 6)
  {
   for (i = 6; i < argc; i += 2)
   {
    if (stricmp(argv[i] , "-t") == 0 && i + 1 < argc)
    {
     GetFullPathName(argv[i + 1], sizeof(szTargetDir), szTargetDir, NULL);
     continue;
    }

    if (stricmp(argv[i], "-p") == 0 && i + 1 < argc)
    {
     pPrefix = argv[i + 1];
     continue;
    }

    usage(argv[0]);
    return -1;
   }
  }

  if (szTargetDir[0] == '/0')
  {
   char *p = strrchr(szInputFile, '//');
   lstrcpyn(szTargetDir, szInputFile, p - szInputFile + 1);
  }

  return DoFileEncrypt(szInputFile, szTargetDir, pPrefix);
 }

 if (stricmp(argv[1], "-d") == 0)
 {
  if (argc != 6 && argc != 8)
  {
   usage(argv[0]);
   return -1;
  }

  if (stricmp(argv[4], "-i") != 0)
  {
   usage(argv[0]);
   return -1;
  }

  GetFullPathName(argv[5], sizeof(szInputFile), szInputFile, NULL);

  if (argc == 8)
  {
   if (stricmp(argv[6] , "-t") != 0)
   {
    usage(argv[0]);
    return -1;
   }

   GetFullPathName(argv[7], sizeof(szTargetDir), szTargetDir, NULL);
  }
  else
  {
   char *p = strrchr(szInputFile, '//');
   lstrcpyn(szTargetDir, szInputFile, p - szInputFile + 1);
  }

  return DoFileDecrypt(szInputFile, szTargetDir);
 }

 if (stricmp(argv[1], "-l") == 0)
 {
  if (argc == 4)
   GetCurrentDirectory(MAX_PATH, szTargetDir);
  else if (argc == 6 && stricmp(argv[4], "-t") == 0)
   strcpy(szTargetDir, argv[5]);
  else
  {
   usage(argv[0]);
   return -1;
  }

  return DoListFile(szTargetDir);
 }

 if (stricmp(argv[1], "-c") == 0)
 {
  if (argc != 8)
  {
   usage(argv[0]);
   return -1;
  }

  if (stricmp(argv[4], "-i") != 0 ||
   stricmp(argv[6], "-i") != 0)
  {
   usage(argv[0]);
   return -1;
  }

  GetFullPathName(argv[5], sizeof(szInputFile), szInputFile, NULL);
  GetFullPathName(argv[7], sizeof(szTargetDir), szTargetDir, NULL);

  return DoCheckFile(szInputFile, szTargetDir);
 }

 usage(argv[0]);

 return -1;
}

tttx
关注
专栏目录
cmd命令加密工具
01-15
cmd命令加密工具
EncryptCLI:用 AutoIt3 编写的开源命令行加密工具-开源
05-31
文件加密工具 - ALBANESE Lab :copyright: 2018-2020 算法：3DES、AES-128、AES-192、AES-256、DES、RC2、RC4 版权所有 :copyright: 2018-2020 Pedro Albanese 来源：https://github.com/pedroalbanese/ encryptcli 访问：http://albanese.atwebpages.com
EncryptTool
weixin_30846599的博客
05-28 293
EncryptTool.h // // Des.h // HungryBear // // Created by Bruce Yang on 12-5-26. // Copyright (c) 2012年 EricGameStudio. All rights reserved. // #import <Foundation/Foundation.h> #import &...
强大的加密工具：encrypt
最新发布
gitblog_00158的博客
09-07 370
强大的加密工具：encrypt 项目地址:https://gitcode.com/gh_mirrors/enc/encrypt 项目介绍 encrypt 是一个基于 Dart 语言的高级加密库，旨在为开发者提供简单易用的加密和解密功能。该项目通过封装 PointyCastle 库，提供了多种加密算法和签名算法的支持，包括 AES、RSA、Salsa20 等。无论是对称加密还是非对称加密，encry...
文件加密工具(源码，带三种加密方式，文件关联，命令行参数)
07-02
没积分下东西了，先上传个以前做的骗点积分。 文件加密解密的东东，带三种加密方式，文件关联，命令行参数。
EncryptTools 字符串 加密 解密 工具
12-18
EncryptTools 字符串 加密 解密 工具，EncryptTools 字符串 加密 解密 工具
USB 加密工具 C源码.zip
12-01
【USB加密工具C源码】是一个专门用于对U盘进行加密的软件开发资源，它包含C语言编写的源代码。这个工具的目的是保护存储在U盘中的数据安全，防止未经授权的访问。源码的可用性使得开发者可以根据自己的需求进行定制...
ClassFinal是一款java class文件安全加密工具
05-23
ClassFinal正是为解决这些问题而设计的一款Java类文件安全加密工具。这款工具能够对编译后的`.class`文件进行加密处理，使得未经授权的用户无法轻易读取或反编译代码，从而提高代码的安全性。 ClassFinal的特点在于...
使用xjar 对Spring-Boot JAR 包加密运行工具，避免源码泄露以及反编译
12-21
总结Xjar 是一个针对Spring Boot JAR包的安全加密工具，它通过加密JAR内的资源和使用自定义ClassLoader实现程序的加密启动和动态解密运行，有效地防止了源码泄露和反编译攻击。使用Xjar，开发者无需修改原有代码，只...
shell-perl-python等脚本文件加密工具
10-30
"shell-perl-python等脚本文件加密工具"这个主题就涉及到这样一个工具——shc。 shc（Shell Script Compiler）是一款开源工具，它能够将Shell脚本转换成二进制可执行文件，从而达到加密和保护脚本源码的目的。shc的...
MLCrypt:简单，轻巧，独立的命令行单个文件加密。-开源
05-08
简单，轻巧的跨平台（Windows / Linux / ARM6 Linux），跨架构（x32 / x64），独立的命令行文件加密程序。 GnuPG可能是跨平台加密的最佳应用程序。 但是，它在Windows PC上的使用可能会带来不便（安装管理员权限；较大的可执行文件大小，可能仅用于一次文件解密；复杂的命令行开关，以进行更强的加密）。 NCrypt将完成此任务，但不能在64位Windows上运行-因此创建了MLCrypt。 该程序的主要目的是级联加密：在现有压缩和加密的存档文件上创建一个加密的外层。 （每个加密层应具有不同的复杂密码。）MLCrypt.zip包含所有可执行文件：Linux，Windows，Raspberry Pi。
encrypt-tool
03-30
用于加密文件的小工具 很多时候遇到需要保护上传的私有数据，如果每一个文件都单独设置一个加密密钥容易遗忘 该软件使用4096位RSA与AES256-CTR算法保护文件 实现多个文件加密密钥不同，但可以被同一对RSA密钥解密 使用方法 生成密钥对 .\windows_x64_encrypt.exe -keygen -o ./my_key_pair 加密文件 .\windows_x64_encrypt.exe -e -i .\Sincerely.flac -o .\Sincerely.enc -pub .\my_key_pair.pub 解密文件 .\windows_x64_encrypt.exe -d -i .\Sincerely.enc -o .\Sincerely.enc.flac -pri .\my_key_pair 打印提示信息 .\windows_x64_encrypt.exe -h
Encrypt加密解密工具
12-13
1.执行start.bat 2.选择single时，只将所选文件的内容加密（解密）显示在文本框中。 3.选择batch时,将所选文件所在的文件夹中所有文件生成加密/解密文件，分别以encode_/decode_为前缀。
易语言EXE加密器源码.zip
07-14
易语言EXE加密器源码.zip
最小，最简单，最实用的DOS加密工具，可加密任何文件！
02-17
DOS下运行，CMD窗口运行也行！无限层加密！
DEncryptTool 加密/解密工具
07-01
网页中DEncryptTool 加密/解密工具
一个简单的凯撒密码的命令行加密工具
Jax_Yang的博客
04-05 959
凯撒密码是很经典的一种简单加密方法，可以将字母的位移视作加密的密钥，因为英文字母只有 26 位，所以加密密钥也只有 26 种可能，这使得破解凯撒密码极其容易（最多只需要试 26 次就可以了）。
整合了大部分常用的加密/解密工具的框架【encryption-tool】
大西瓜的博客
02-18 769
RSA、SHA-1、SHA-256、SHA-512、ECC、MD5、BCrypt、AES
凯撒密码加密器（命令行版）
m0_73200695的博客
08-30 846
凯撒密码加密器（命令行版）
Java文件加密器项目源码详解
资源摘要信息: "Java文件加密器项目源码" 1. Java基础与项目构建 Java是一种广泛使用的面向对象的编程语言，具有跨平台、多线程和安全性高等特点。在构建Java文件加密器项目时，通常会使用集成开发环境（IDE），...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值