Hardict

DES与AES实现

代码先扔这，区域赛打完来补

/*
DES实现
Author: Hardict
E-mail: [email protected]/[email protected]
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

using LL = long long;
using ULL = unsigned long long;
using LDB = long double;
const int MAXN = 1e5 + 5;
const int INF = 2e9 + 5;
map MP_Hex;
map MP_Hex_inv;
string btos(int x, int d);              // d位转二进制转string
int stob(string s, int d);              // d位string转int
vector> getK(bitset<64> K);  //生成子密钥
// 0加密,1解密(提前生成子密钥)
bitset<64> crypt(bitset<64> M, vector> K, int op);

int main() {
  freopen("DES.in", "r", stdin);
  freopen("DES.out", "w", stdout);
  for (int i = 0; i < 10; i++) MP_Hex[i] = '0' + i, MP_Hex_inv['0' + i] = i;
  for (int i = 10; i < 16; i++)
    MP_Hex[i] = 'A' + (i - 10), MP_Hex_inv['A' + (i - 10)] = i;
  string plain, secret;
  //明文
  plain = "";
  for (int i = 0; i < 16; i++) {
    char ch;
    cin >> ch;
    int x = MP_Hex_inv[ch];
    plain += btos(x, 4);
  }
  // for (int i = 0; i < 16; i++) plain += btos(i, 4);
  bitset<64> M(plain);
  cout << "Plaintext:" << endl << "M: " << M << endl;
  //密钥
  secret = "";
  for (int i = 0; i < 16; i++) {
    char ch;
    cin >> ch;
    int x = MP_Hex_inv[ch];
    secret += btos(x, 4);
  }
  cout << secret << endl;
  /*   secret += btos(1, 4) + btos(3, 4);
    secret += btos(3, 4) + btos(4, 4);
    secret += btos(5, 4) + btos(7, 4);
    secret += btos(7, 4) + btos(9, 4);
    secret += btos(9, 4) + btos(11, 4);
    secret += btos(11, 4) + btos(12, 4);
    secret += btos(13, 4) + btos(15, 4);
    secret += btos(15, 4) + btos(1, 4); */
  bitset<64> K(secret);
  cout << "Secret key:" << endl << "K: " << K << endl << endl;
  auto K_array = getK(K);

  string s, t;
  //加密
  cout << "----" << endl << "encrypt:" << endl;
  auto C = crypt(M, K_array, 0);
  cout << "C(bin): " << C << endl;
  s = "", t = C.to_string();
  for (int i = 0; i < 16; i++) {
    int x = stob(t.substr(i * 4, 4), 4);
    s += MP_Hex[x];
  }
  cout << "C(hex): " << s << endl;
  //解密
  cout << "----" << endl << "decrypt:" << endl;
  auto C_inv = crypt(C, K_array, 1);
  cout << "C_inv(bin): " << C_inv << endl;
  return 0;
}

bitset<32> fuc1(bitset<32> R, bitset<48> K);
bitset<64> crypt(bitset<64> M, vector> K, int op) {
  //初始置换
  static int IP1[8][8] = {
      {58, 50, 42, 34, 26, 18, 10, 2}, {60, 52, 44, 36, 28, 20, 12, 4},
      {62, 54, 46, 38, 30, 22, 14, 6}, {64, 56, 48, 40, 32, 24, 16, 8},
      {57, 49, 41, 33, 25, 17, 9, 1},  {59, 51, 43, 35, 27, 19, 11, 3},
      {61, 53, 45, 37, 29, 21, 13, 5}, {63, 55, 47, 39, 31, 23, 15, 7}};
  string s;
  s = "";
  for (int i = 0; i < 8; i++)
    for (int j = 0; j < 8; j++) {
      // bitset是从高位开始存
      s += '0' + M[64 - IP1[i][j]];
    }
  cout << "初始置换(64-64):" << endl;
  cout << "M_IP1: " << s << endl;
  bitset<32> L(s.substr(0, s.size() / 2)),
      R(s.substr(s.size() / 2, s.size() / 2));
  cout << "L0: " << L << endl;
  cout << "R0: " << R << endl;
  cout << endl;

  vector, bitset<32>>> LR;
  LR.push_back(make_pair(L, R));
  // L = L ^ fuc1(R, K[1]);
  // cout << L << endl;
  if (op == 0) {
    for (int i = 0; i < 16; i++) {
      cout << "加密第" << i + 1 << "次迭代" << endl;
      L = LR[i].first;
      R = LR[i].second;
      L = L ^ fuc1(R, K[i + 1]);
      LR.push_back(make_pair(R, L));
      cout << "L" << i + 1 << ": " << R << endl;
      cout << "R" << i + 1 << ": " << L << endl;
      cout << endl;
    }
  } else if (op == 1) {
    for (int i = 16; i >= 1; i--) {
      cout << "解密第" << 17 - i << "次迭代" << endl;
      L = LR[LR.size() - 1].first;
      R = LR[LR.size() - 1].second;
      L = L ^ fuc1(R, K[i]);
      // cout << K[i] << endl;
      LR.push_back(make_pair(R, L));
      cout << "L" << 17 - i << ": " << R << endl;
      cout << "R" << 17 - i << ": " << L << endl;
      cout << endl;
    }
  }
  //最终置换
  static int IP_1[8][8] = {
      {40, 8, 48, 16, 56, 24, 64, 32}, {39, 7, 47, 15, 55, 23, 63, 31},
      {38, 6, 46, 14, 54, 22, 62, 30}, {37, 5, 45, 13, 53, 21, 61, 29},
      {36, 4, 44, 12, 52, 20, 60, 28}, {35, 3, 43, 11, 51, 19, 59, 27},
      {34, 2, 42, 10, 50, 18, 58, 26}, {33, 1, 41, 9, 49, 17, 57, 25}};
  string t;
  s = LR[16].second.to_string() + LR[16].first.to_string();
  cout << "R16L16:" << endl;
  cout << s << endl;
  t = "";
  for (int i = 0; i < 8; i++)
    for (int j = 0; j < 8; j++) t += s[IP_1[i][j] - 1];
  // cout << t << endl;
  bitset<64> res(t);
  return res;
}

bitset<32> fuc1(bitset<32> R, bitset<48> K) {
  // E盒扩展
  static int E[8][6] = {{32, 1, 2, 3, 4, 5},      {4, 5, 6, 7, 8, 9},
                        {8, 9, 10, 11, 12, 13},   {12, 13, 14, 15, 16, 17},
                        {16, 17, 18, 19, 20, 21}, {20, 21, 22, 23, 24, 25},
                        {24, 25, 26, 27, 28, 29}, {28, 29, 30, 31, 32, 1}};
  string s;
  s = "";
  for (int i = 0; i < 8; i++)
    for (int j = 0; j < 6; j++) s += '0' + R[32 - E[i][j]];
  bitset<48> ER(s);
  cout << "E盒扩展(32->48):" << endl;
  cout << ER << endl;
  ER = ER ^ K;
  cout << "异或运算:" << endl;
  cout << ER << endl;
  // S盒转换
  static int S[8][4][16] = {
      {{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
       {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
       {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
       {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},

      {{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
       {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
       {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
       {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},

      {{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
       {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
       {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
       {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},

      {{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
       {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
       {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
       {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},

      {{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
       {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
       {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
       {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},

      {{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
       {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
       {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
       {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},

      {{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
       {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
       {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
       {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},

      {{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
       {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
       {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
       {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}};
  //
  s = ER.to_string();
  string t;
  t = "";
  // cout << s << endl;
  for (int i = 0; i < 8; i++) {
    // cout << i << endl;
    //分组拆分
    string s1, s2;
    s1 = s[i * 6];
    s1 = s1 + s[i * 6 + 5];
    s2 = s.substr(i * 6 + 1, 4);
    int row, col;
    // cout << s1 << " " << s2 << endl;
    row = stob(s1, 2), col = stob(s2, 4);
    // cout << row << " " << col << endl;
    t += btos(S[i][row][col], 4);
  }
  cout << "S盒运算:" << endl;
  cout << t << endl;
  // P盒置换
  static int P[8][4] = {{16, 7, 20, 21}, {29, 12, 28, 17}, {1, 15, 23, 26},
                        {5, 18, 31, 10}, {2, 8, 24, 14},   {32, 27, 3, 9},
                        {19, 13, 30, 6}, {22, 11, 4, 25}};
  s = "";
  for (int i = 0; i < 8; i++)
    for (int j = 0; j < 4; j++) s += t[P[i][j] - 1];
  cout << "P盒置换" << endl;
  cout << s << endl;
  bitset<32> res(s);
  return res;
}

vector> getK(bitset<64> K) {
  //初步交换
  static int PC1[8][7] = {
      {57, 49, 41, 33, 25, 17, 9},  {1, 58, 50, 42, 34, 26, 18},
      {10, 2, 59, 51, 43, 35, 27},  {19, 11, 3, 60, 52, 44, 36},
      {63, 55, 47, 39, 31, 23, 15}, {7, 62, 54, 46, 38, 30, 22},
      {14, 6, 61, 53, 45, 37, 29},  {21, 13, 5, 28, 20, 12, 4}};
  string s = "";
  for (int i = 0; i < 8; i++)
    for (int j = 0; j < 7; j++) s += '0' + K[64 - PC1[i][j]];
  bitset<56> _K(s);
  cout << "初步置换:" << endl;
  cout << "K': " << _K << endl;
  bitset<28> C(s.substr(0, s.size() / 2)),
      D(s.substr(s.size() / 2, s.size() / 2));
  cout << "C0: " << C << endl;
  cout << "D0: " << D << endl;
  vector, bitset<28>>> CD;
  CD.push_back(make_pair(C, D));
  cout << endl;
  //左移变换
  static int L_Mv[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
  cout << "左移过程" << endl;
  for (int i = 0; i < 16; i++) {
    C = CD[i].first, D = CD[i].second;
    bitset<28> tmp;
    //利用溢出得到循环左移解
    tmp = C >> (28 - L_Mv[i]);
    C = (C << L_Mv[i]) | (tmp);
    tmp = D >> (28 - L_Mv[i]);
    D = (D << L_Mv[i]) | (tmp);
    CD.push_back(make_pair(C, D));
    cout << "C" << i + 1 << ": " << C << endl;
    cout << "D" << i + 1 << ": " << D << endl;
  }
  cout << endl;
  //子密钥生成
  static int PC2[8][6] = {{14, 17, 11, 24, 1, 5},   {3, 28, 15, 6, 21, 10},
                          {23, 19, 12, 4, 26, 8},   {16, 7, 27, 20, 13, 2},
                          {41, 52, 31, 37, 47, 55}, {30, 40, 51, 45, 33, 48},
                          {44, 49, 39, 56, 34, 53}, {46, 42, 50, 36, 29, 32}};
  vector> res;
  bitset<48> p;
  res.push_back(p);
  cout << "16个子密钥" << endl;
  for (int i = 1; i <= 16; i++) {
    s = "";
    string org = CD[i].first.to_string() + CD[i].second.to_string();
    for (int j = 0; j < 8; j++)
      for (int k = 0; k < 6; k++) s += org[PC2[j][k] - 1];
    bitset<48> p(s);
    cout << "K" << i << ": " << p << endl;
    res.push_back(p);
  }
  cout << endl;
  return res;
}

// d位转二进制转string
string btos(int x, int d) {
  string s = "";
  for (int i = 0; i < d; i++) s += '0' + ((x >> i) & 1);
  reverse(s.begin(), s.end());
  return s;
}

// d位string转int
int stob(string s, int d) {
  int res = 0;
  for (int i = 0; i < d; i++) res = (res << 1) + (s[i] == '1');
  return res;
}

/*
AES实现
Author: Hardict
E-mail: [email protected]/[email protected]
 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

using LL = long long;
using ULL = unsigned long long;
using LDB = long double;
using UI8 = unsigned char;
const int MAXN = 1e5 + 5;
const int INF = 2e9 + 5;
const int AES_ROUND = 10;
const int AES_BLOCK_SIZE = 16;
map MP_Hex;
map MP_Hex_inv;
vector Shift_rows(vector org);
vector Shift_rows_inv(vector org);
vector Gene_Keys(vector org);
vector AES_encrypt_128(vector P, vector keys);
vector AES_decrypt_128(vector C, vector keys);
int multi_2(int x);

int main() {
  freopen("AES.in", "r", stdin);
  freopen("AES.out", "w", stdout);
  for (int i = 0; i < 10; i++) MP_Hex[i] = '0' + i, MP_Hex_inv['0' + i] = i;
  for (int i = 10; i < 16; i++)
    MP_Hex[i] = 'A' + (i - 10), MP_Hex_inv['A' + (i - 10)] = i;
  vector Plain;
  vector K;
  Plain.resize(AES_BLOCK_SIZE);
  K.resize(AES_BLOCK_SIZE);
  for (int i = 0; i < AES_BLOCK_SIZE; i++) {
    char ch = getchar();
    while (isspace(ch)) ch = getchar();
    Plain[i] = MP_Hex_inv[ch];
  }
  for (int i = 0; i < AES_BLOCK_SIZE; i++) {
    char ch = getchar();
    while (isspace(ch)) ch = getchar();
    K[i] = MP_Hex_inv[ch];
  }
  printf("Plaintext:\n");
  for (int i = 0; i < AES_BLOCK_SIZE; i++)
    printf("%d%c", Plain[i], (i == AES_BLOCK_SIZE - 1) ? '\n' : ' ');
  auto Keys = Gene_Keys(K);
  printf("Keys:\n");
  for (int i = 0; i < AES_ROUND + 1; i++) {
    for (int j = 0; j < AES_BLOCK_SIZE; j++)
      printf("%d ", Keys[i * AES_BLOCK_SIZE + j]);
    printf("\n");
  }
  printf("\n");
  auto C = AES_encrypt_128(Plain, Keys);
  printf("\nCiphertext:\n");
  for (int i = 0; i < AES_BLOCK_SIZE; i++)
    printf("%d%c", C[i], (i == AES_BLOCK_SIZE - 1) ? '\n' : ' ');
  auto P1 = AES_decrypt_128(C, Keys);
  printf("\ndecrypt:\n");
  for (int i = 0; i < AES_BLOCK_SIZE; i++)
    printf("%d%c", P1[i], (i == AES_BLOCK_SIZE - 1) ? '\n' : ' ');
  return 0;
}

static int S[256] = {
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
    0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
    0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
    0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
    0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
    0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
    0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
    0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
    0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
    0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
    0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
    0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
    0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
    0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
    0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
    0xb0, 0x54, 0xbb, 0x16};

static int S_inv[256] = {
    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
    0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
    0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32,
    0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,
    0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
    0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50,
    0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,
    0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
    0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41,
    0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,
    0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
    0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b,
    0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,
    0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
    0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d,
    0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,
    0x55, 0x21, 0x0c, 0x7d};

vector AES_encrypt_128(vector P, vector keys) {
  vector res;
  res.resize(AES_BLOCK_SIZE);
  for (int i = 0; i < AES_BLOCK_SIZE; i++) {
    res[i] = P[i] ^ keys[i];
    // printf("%d\n", res[i]);
  }
  for (int k = 1; k < AES_ROUND; k++) {
    vector tmp;
    tmp.resize(AES_BLOCK_SIZE);
    for (int i = 0; i < AES_BLOCK_SIZE; i++) {
      tmp[i] = S[res[i]];
      // cout << "tmp:" << k << " " << i << " " << tmp[i] << endl;
    }
    tmp = Shift_rows(tmp);
    /*
     * MixColumns
     * [02 03 01 01]   [s0  s4  s8  s12]
     * [01 02 03 01] . [s1  s5  s9  s13]
     * [01 01 02 03]   [s2  s6  s10 s14]
     * [03 01 01 02]   [s3  s7  s11 s15]
     */
    for (int i = 0; i < AES_BLOCK_SIZE; i += 4) {
      int x = tmp[i] ^ tmp[i + 1] ^ tmp[i + 2] ^ tmp[i + 3];
      res[i] = multi_2(tmp[i] ^ tmp[i + 1]) ^ tmp[i] ^ x;
      res[i + 1] = multi_2(tmp[i + 1] ^ tmp[i + 2]) ^ tmp[i + 1] ^ x;
      res[i + 2] = multi_2(tmp[i + 2] ^ tmp[i + 3]) ^ tmp[i + 2] ^ x;
      res[i + 3] = multi_2(tmp[i + 3] ^ tmp[i]) ^ tmp[i + 3] ^ x;
    }

    for (int i = 0; i < AES_BLOCK_SIZE; i++) {
      // cout << "res:" << k << " " << i << " " << tmp[i] << endl;
      res[i] ^= keys[k * AES_BLOCK_SIZE + i];
    }
  }

  for (int i = 0; i < AES_BLOCK_SIZE; i++) res[i] = S[res[i]];
  res = Shift_rows(res);
  for (int i = 0; i < AES_BLOCK_SIZE; i++)
    res[i] ^= keys[AES_ROUND * AES_BLOCK_SIZE + i];
  return res;
}

vector AES_decrypt_128(vector C, vector keys) {
  vector res;
  res.resize(AES_BLOCK_SIZE);
  for (int i = 0; i < AES_BLOCK_SIZE; i++)
    res[i] = C[i] ^ keys[AES_ROUND * AES_BLOCK_SIZE + i];
  res = Shift_rows_inv(res);
  for (int i = 0; i < AES_BLOCK_SIZE; i++) {
    res[i] = S_inv[res[i]];
    // cout << res[i] << endl;
  }

  for (int k = 1; k < AES_ROUND; k++) {
    vector tmp;
    tmp.resize(AES_BLOCK_SIZE);
    for (int i = 0; i < AES_BLOCK_SIZE; i++) {
      tmp[i] = res[i] ^ keys[(AES_ROUND - k) * AES_BLOCK_SIZE + i];
      // cout << tmp[i] << endl;
    }

    /*
     * Inverse MixColumns
     * [0e 0b 0d 09]   [s0  s4  s8  s12]
     * [09 0e 0b 0d] . [s1  s5  s9  s13]
     * [0d 09 0e 0b]   [s2  s6  s10 s14]
     * [0b 0d 09 0e]   [s3  s7  s11 s15]
     */
    for (int i = 0; i < AES_BLOCK_SIZE; i += 4) {
      int x = tmp[i] ^ tmp[i + 1] ^ tmp[i + 2] ^ tmp[i + 3];
      res[i] = multi_2(tmp[i] ^ tmp[i + 1]) ^ tmp[i] ^ x;
      res[i + 1] = multi_2(tmp[i + 1] ^ tmp[i + 2]) ^ tmp[i + 1] ^ x;
      res[i + 2] = multi_2(tmp[i + 2] ^ tmp[i + 3]) ^ tmp[i + 2] ^ x;
      res[i + 3] = multi_2(tmp[i + 3] ^ tmp[i]) ^ tmp[i + 3] ^ x;
      int u, v;
      u = multi_2(multi_2(tmp[i] ^ tmp[i + 2]));
      v = multi_2(multi_2(tmp[i + 1] ^ tmp[i + 3]));
      x = multi_2(u ^ v);
      res[i] ^= x ^ u;
      res[i + 1] ^= x ^ v;
      res[i + 2] ^= x ^ u;
      res[i + 3] ^= x ^ v;
      // cout << res[i] << endl;
    }
    res = Shift_rows_inv(res);

    for (int i = 0; i < AES_BLOCK_SIZE; i++) {
      res[i] = S_inv[res[i]];
    }
  }

  for (int i = 0; i < AES_BLOCK_SIZE; i++) res[i] ^= keys[i];
  return res;
}

vector Gene_Keys(vector org) {
  static int RC[AES_ROUND] = {0x01, 0x02, 0x04, 0x08, 0x10,
                              0x20, 0x40, 0x80, 0x1b, 0x36};
  vector res;
  res.resize((AES_ROUND + 1) * AES_BLOCK_SIZE);
  for (int i = 0; i < AES_BLOCK_SIZE; i++) res[i] = org[i];
  // bitset;
  for (int k = 0; k < AES_ROUND; k++) {
    vector S_;
    S_.resize(4);
    for (int i = AES_BLOCK_SIZE * (k + 1) - 4, j = 3;
         i < AES_BLOCK_SIZE * (k + 1); i++, j = (j + 1) % 4)
      S_[j] = S[res[i]];
    S_[0] ^= RC[k];
    // cout << (S_[0] ^ res[k * AES_BLOCK_SIZE]) << endl;
    for (int i = 0; i < 4; i++)
      res[(k + 1) * AES_BLOCK_SIZE + i] = S_[i] ^ res[k * AES_BLOCK_SIZE + i];
    for (int i = 4; i < AES_BLOCK_SIZE; i++)
      res[(k + 1) * AES_BLOCK_SIZE + i] =
          res[(k + 1) * AES_BLOCK_SIZE + i - 4] ^ res[k * AES_BLOCK_SIZE + i];
  }
  return res;
}

vector Shift_rows(vector org) {
  vector res;
  res.resize(AES_BLOCK_SIZE);
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++) res[i * 4 + j] = org[i * 4 + (j + i) % 4];
  // res[1] = org[5], res[5] = org[9], res[9] = org[13], res[13] = org[1];
  // res[2] = org[10], res[10] = org[2], res[6] = org[14], res[14] = org[6];
  // res[15] = org[11], res[11] = org[7], res[7] = org[3], res[3] = org[15];
  // res[0] = org[0], res[4] = org[4], res[8] = org[8], res[12] = org[12];
  return res;
}

vector Shift_rows_inv(vector org) {
  vector res;
  res.resize(AES_BLOCK_SIZE);
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++) res[i * 4 + j] = org[i * 4 + (j - i + 4) % 4];
  // res[1] = org[13], res[5] = org[1], res[9] = org[5], res[13] = org[9];
  // res[2] = org[10], res[6] = org[14], res[10] = org[2], res[14] = org[6];
  // res[3] = org[7], res[7] = org[11], res[11] = org[15], res[15] = org[3];
  // res[0] = org[0], res[4] = org[4], res[8] = org[8], res[12] = org[12];
  return res;
}

int multi_2(int x) {
  int res = x << 1;
  res = (uint8_t)res;
  if (x & (1 << 7)) res ^= 0x1b;
  res = (uint8_t)res;
  // cout << x << " " << res << endl;
  return res;
}

高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
Tor Browser配置方法淡水猫. 网络安全服务器
密码学中有两种常见的加密方式：对称加密：加密和解密使用同一个秘钥，如AES、DES等算法。非对称加密：加密和解密使用不相同的密钥，这两个秘钥分别称为公钥（publickey）和私钥（privatekey）——也就是说私钥可以解开公钥加密的数据，反之亦然（很神奇的数学原理）。Tor是一个三重代理（也就是说Tor每发出一个请求会先经过Tor网络的3个节点），其网络中有两种主要服务器角色：中继服务器：负
python 实现eulers totient欧拉方程算法 luthane 算法 python 开发语言
eulerstotient欧拉方程算法介绍欧拉函数（Euler’sTotientFunction），通常表示为()，是一个与正整数相关的函数，它表示小于或等于的正整数中与互质的数的数目。欧拉函数在数论和密码学中有广泛的应用。欧拉函数的性质1.**对于质数，有φ(p)=p−1∗∗φ(p)=p−1^{**}φ(p)=p−1∗∗。2.**如果是质数的次幂，即n=pkn=p^kn=pk，则φ(n)=pk−
网络安全的相关比赛有哪些？需要掌握哪些必备技能？网安学习 web安全安全网络安全的相关比赛有哪
01、CTF（夺旗赛）这是一种最常见的网络安全竞技形式，要求参赛者在限定时间内解决一系列涉及密码学、逆向工程、漏洞利用、取证分析等领域的挑战，获取标志（flag）并提交得分。通过举办CTF来培养网络安全人才，已经发展成为了国际网络安全圈的共识。CTF赛事可以分为线上赛和线下赛，线上赛通常是解题模式（Jeopardy），线下赛通常是攻防模式（Attack-Defense）。CTF赛事的代表性线下赛事
现代密码学2.2、2.3--由“一次一密”引出具有完美安全的密码方案共同缺点 WeidanJi 现代密码学概率论密码学数学
现代密码学2.2、2.3--由“一次一密/One-TimePad”引出具有完美安全的密码方案共同缺点One-TimePad密码方案定义正确性/correctness完美隐藏性/perfectlysecret具有完美隐藏性的密码方案的共同缺点特例缺点共同缺点博主正在学习INTRODUCTIONTOMODERNCRYPTOGRAPHY(SecondEdition)--JonathanKatz,Yehu
【网络安全】密码学概述衍生星球《网络安全》web安全密码学安全
1.密码学概述1.1定义与目的密码学是一门研究信息加密和解密技术的科学，其核心目的是确保信息在传输和存储过程中的安全性。密码学通过加密算法将原始信息（明文）转换成难以解读的形式（密文），只有拥有正确密钥的接收者才能将密文还原为原始信息。这一过程不仅保护了信息的机密性，还确保了信息的完整性和真实性。1.2密码学的发展历史密码学的历史可以追溯到古代，最早的加密方法包括替换密码和换位密码。随着时间的推移
CTF 竞赛密码学方向学习路径规划 David Max CTF 学习笔记密码学 ctf 信息安全
目录计算机科学基础计算机科学概念的引入、兴趣的引导开发环境的配置与常用工具的安装WattToolkit（Steam++）、机场代理Scoop（Windows用户可选）常用Python库SageMathLinux小工具yafuOpenSSLMarkdown编程基础Python其他编程语言、算法与数据结构（可选）数学基础离散数学与抽象代数复杂性分析密码学的正式学习兴趣的培养做题小技巧系统学习需要了解并
NISP 一级 —— 考证笔记合集 SRC_BLUE_17 网络安全资源导航 #网络安全相关笔记笔记网络安全证书获取 NISP
该笔记为导航目录，在接下来一段事件内，我会每天发布我关于考取该证书的相关笔记。当更新完成后，此条注释会被删除。第一章信息安全概述1.1信息与信息安全1.2信息安全威胁1.3信息安全发展阶段与形式1.4信息安全保障1.5信息系统安全保障第二章信息安全基础技术2.1密码学2.2数字证书与公钥基础设施2.3身份认证2.4访问控制2.5安全审计第三章网络安全防护技术3.1网络基础知识3.2网络安全威胁3.
解锁Apache Shiro：新手友好的安全框架指南(一)——整体架构与身份认证_apache shiro的配置包括安全管理器(2) 2401_84281748 程序员 apache 安全架构
ApacheShiro是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理，可用于保护任何应用程序——从命令行应用程序、移动应用程序到最大的web和企业应用程序。Shiro提供了应用程序安全API来执行以下方面：Authentication（认证）：验证用户身份，即用户登录。Authorization（授权）：访问控制Cryptography（密码学）：保护或隐藏私密数
零知识证明-公钥分发方案DH(（六） yunteng521 区块链零知识证明算法区块链密钥分发 DH
前言椭圆曲线配对，是各种加密构造方法(包括确定性阀值签名、zk-SNARKs以及相似的零知识证明)的关键元素之一。椭圆曲线配对(也叫“双线性映射”)有了30年的应用历史，然而最近这些年才把它应用在密码学领域。配对带来了一种“加密乘法”的形式，这很大的拓展了椭圆曲线协议的应用范围。本文的目的是详细介绍椭圆曲线配对，并大致解释它的内部原理先了解DH协议Diffie-Hellman协议简称DH，是一种公
【区块链 + 人才服务】区块链综合实训平台 | FISCO BCOS应用案例 | FISCO BCOS应用案例 FISCO_BCOS 2023FISCO BCOS产业应用发展报告区块链人才服务
区块链综合实训平台由秉蔚信息面向高校区块链专业开发，是一款集软硬件于一体的实验实训产品。该产品填补了高校区块链相关专业和课程在实验室实训环节的空缺，覆盖了区块链原理与技术、区块链开发、区块链运维、区块链安全、区块链实训案例等核心实训教学资源，分层次地融入到实训教学中去，为高校的区块链实验实训提供领先的一体化实验教学环境。平台内置丰富的实验教学资源，课程涵盖区块链导论、区块链密码学应用、区块链网络与
python数学库目录库相关 yanghy228
数学相关的库math：数学相关的库random：随机库软件测试、密码学当中经常使用有限定条件的随机数randint(1,5)randchoice(["aa",'bb','cc'])文件和目录访问相关的库linux命令行：ls查看文件名ls-lpwd查看当前所在位置cd绝对路径（/）相对路径（..)(./一般省略)建立文件夹：mkdir（-p多层建立）删除文件夹：rmdir包括文件的话（rm-rf）
2021福布斯富豪榜前十半数关注比特币和区块链 Eslacoin艾斯拉量化
中本聪结合多位朋克社群的既有想法创造了比特币，其背后的科技和概念并非均为创新，但其利用密码学等控制币的发行和管理的想法带来了创新改变。随着越来越多的组织、群体和个人开始接受比特币，以比特币为代表的加密世界正不断扩大发展。尽管近一个月以来，比特币“四面楚歌”。但多名亿万富翁的目光仍关注在比特币上，相关资产配置中也不乏押注。值得注意的是，在2021年福布斯富豪榜中，就不乏加密的积极研究者。亚马逊杰夫·
SSL/TLS协议详解(二)：密码套件，哈希，加密，密钥交换算法 meroykang 网络安全 ssl 网络协议网络
目录SSL的历史哈希加密对称密钥加密非对称密钥加密密钥交换算法了解SSL中的加密类型密钥交换算法Diffie-HellmanKeyExchange解释作为一名安全爱好者，我一向很喜欢SSL（目前是TLS）的运作原理。理解这个复杂协议的基本原理花了我好几天的时间，但只要你理解了底层的概念和算法，就会感觉整个协议其实很简单。在学习SSL运作原理的过程中，我获益匪浅。回想起在大学期间学到的密码学，那段时
零基础转行学网络安全怎么样？能找到什么样的工作？爱吃小石榴16 web安全安全人工智能运维学习
网络安全对于现代社会来说变得越来越重要，但是很多人对于网络安全的知识却知之甚少。那么，零基础小白可以学网络安全吗？答案是肯定的。零基础转行学习网络安全是完全可行的，但需要明确的是，网络安全是一个既广泛又深入的领域，包含了网络协议、系统安全、应用安全、密码学、渗透测试、漏洞挖掘、安全编程、安全运维等多个方面。。网络安全是一个快速发展的领域，对专业人才的需求不断增长。以下是一些关于零基础转行学习网络安
【网络安全面经】渗透面经、安服面经、红队面经、hw面经应有尽有这一篇真的够了 webfker from 0 to 1 github git java
目录面经牛客奇安信面经（五星推荐）牛客面经（推荐）渗透测试面经（推荐）渗透测试技巧计网面经SQL注入漏洞注入绕过XXE漏洞最强面经Github面经模拟面WEB安全PHP安全网络安全密码学一、青藤二、360三、漏洞盒子四、未知厂商五、长亭-红队六、qax七、天融信八、安恒九、长亭十、国誉网安十一、360-红队十二、天融信十三、长亭-2十四、360-2十五、极盾科技十六、阿里十七、长亭3十八、qax-
CTF---密码学(1)--古典密码-理论与实战详解洛一方 #渗透测试从入门到入土网络安全---白帽从小白到大神密码学网络安全 web安全网络攻击模型安全系统安全计算机网络
密码学的三个发展阶段：密码学的首要目的是隐藏信息的涵义，而并不是隐藏信息的存在，这是密码学与隐写术的一个重要区别。密码学的发展大概经历了三个阶段:古典密码阶段(1949年以前)：早期的数据加密技术比较简单，复杂程度不高，安全性较低，大部分都是一些具有艺术特征的字谜。随着工业革命的到来和二次世界大战的爆发,数据加密技术有了突破性的发展。出现了一些比较复杂的加密算法以及机械的加密设备。近代密码阶段(1
HTTP协议26丨信任始于握手：TLS1.2连接过程解析程序员zhi路软件工程&软件测试 http 网络协议网络
经过前几讲的介绍，你应该已经熟悉了对称加密与非对称加密、数字签名与证书等密码学知识。有了这些知识“打底”，现在我们就可以正式开始研究HTTPS和TLS协议了。HTTPS建立连接当你在浏览器地址栏里键入“https”开头的URI，再按下回车，会发生什么呢？回忆一下第8讲的内容，你应该知道，浏览器首先要从URI里提取出协议名和域名。因为协议名是“https”，所以浏览器就知道了端口号是默认的443，它
智能合约与身份验证：区块链技术的创新应用星途码客前沿科技智能合约区块链
一、引言区块链，一个近年来备受瞩目的技术名词，已经从最初的数字货币领域扩展到了众多行业。那么，究竟什么是区块链？它为何如此重要？本文将深入剖析区块链技术的原理、应用及未来发展。二、区块链的基本概念区块链，从本质上讲，是一个去中心化的分布式数据库。它由一系列按照时间顺序排列的数据块组成，并采用密码学方式保证不可篡改和不可伪造。每一个数据块中包含了一定时间内的所有交易信息，包括交易的数量、交易的时间、
零知识证明：哈希函数-Poseidon2代码解析与benchmark HIT夜枭零知识证明零知识证明哈希算法区块链
1、哈希函数(HashFunction)与Poseidon在密码学中，哈希函数是一种将任意大小的数据映射到固定大小的输出的函数。哈希函数的输出称为哈希值或哈希码。哈希函数具有单向性和抗碰撞性。一些常见的哈希函数包括MD5、SHA-1、SHA-256和SHA-3。例如，假设您要验证一个文件的完整性。您可以使用哈希函数来计算该文件的哈希值。然后，您可以将该哈希值与文件的预期哈希值进行比较。如果两个哈希
密码学基础知识山登绝顶我为峰 3(^v^)3 基础密码学密码学安全
密码学基础知识信息安全三要素(CIA)机密性（Confidentiality）完整性（Integrity）可用性（Availability）信息安全四大安全属性机密性完整性可认证性不可抵赖性Kerckhoffs假设在密码分析中，除密钥以外，密码分析者知道密码算法的每一个设计细节。密码算法的安全性应依赖于密钥的保密性，而非算法本身的保密性。安全性无条件安全性无论有多少可用的可用的计算资源和信息，都不
密码学 star.29 计算机网络密码学
密码学在密码学中，有一个五元组，即{明文、密文、密钥、加密算法、解密算法}，对应的加密方案称为密码体制（或密码）。明文是作为加密输入的原始信息，即消息的原始形式，通常用m(Message)或p(Plaintext)表示。所有可能明文的有限集称为明文空间，通常用M或P来表示。密文是明文经加密变换后的结果，即消息被加密处理后的形式，通常用c(Ciphertext)表示。所有可能密文的有限集称为密文空间
信息安全（密码学）---数字证书、kpi体系结构、密钥管理、安全协议、密码学安全应用魔同信息安全 ssl web ssh 密码学网络安全
数字证书数字证书(DigitalCertificate,类似身份证的作用)----防伪标志CA(CertificateAuthority,电子商务认证授权机构)----ca用自己私钥进行数字签名数字证书姓名，地址，组织所有者公钥证书有效期认证机构数字签名■公钥证书的种类与用途■证书示例·序列号04·签名算法md5RSA·颁发者·有效起始日期·有效终止日期·公钥■数字证书按类别可分为个人证书、机构证
什么是密码学？缓缓躺下密码学
什么是密码学？密码学是一种通过使用编码算法、哈希和签名来保护信息的实践。此信息可以处于静态（例如硬盘驱动器上的文件）、传输中（例如两方或多方之间交换的电子通信）或使用中（在对数据进行计算时）。密码学有四个主要目标：保密性–仅将信息提供给授权男用户。完整性–确保信息未受到操控。身份验证–确认信息的真实性或用户的身份。不可否认性–防止用户否认先前的承诺或操作。密码学使用许多低级密码算法来实现这些信息安
从密码学角度看网络安全：加密技术的最新进展亿林数据密码学 web安全安全网络安全
在数字化时代，网络安全已成为不可忽视的重大问题。随着计算机技术和网络应用的飞速发展，黑客和网络攻击手段日益复杂，对个人、企业乃至国家的信息安全构成了严重威胁。密码学作为网络安全领域的核心支柱，其发展对于保护信息安全具有至关重要的作用。本文将探讨加密技术的最新进展，以及这些进展如何助力网络安全。加密技术的基础与重要性密码学是研究信息的机密性、完整性和可用性的科学，它确保信息在传输和存储过程中不被未经
每日IT资讯（2022-03-10）史蒂芬周_jianshu
##每日IT资讯（2022-03-10）#####掘金资讯[1.密码学开源项目BabaSSL发布8.3.0稳定版本](https://juejin.cn/news/7073312793562185758)#####InfoQ热门话题[1.植树节活动来袭，快来和InfoQ技术大会一起种果树吧！](https://www.infoq.cn/article/fl1DjvQPTuvXAlt4PNPp)[2
密码学之椭圆曲线（ECC）零度° 密码学密码学 python
1.椭圆曲线加密ECC概述1.1ECC定义与原理椭圆曲线密码学（ECC）是一种基于椭圆曲线数学的公钥密码体系，它利用了椭圆曲线上的点构成的阿贝尔群和相应的离散对数问题来实现加密和数字签名。ECC的安全性依赖于椭圆曲线离散对数问题（ECDLP）的难解性。在ECC中，首先需要选择一个椭圆曲线和一个基点，然后生成密钥对。私钥是一个随机整数，而公钥是这个随机整数与基点的标量乘积。ECC的加密过程包括选择一
实验吧CTF密码学Writeup-古典密码Writeup syxvip
古典密码分值：10来源：北邮天枢战队难度：易参与人数：6803人GetFlag：2507人答题人数：2791人解题通过率：90%密文内容如下{796785123677084697688798589686967847871657279728278707369787712573798465}请对其进行解密提示：1.加解密方法就在谜面中2.利用key值的固定结构格式：CTF{}密文全是数字，ascll码
pypbc双线性对库的使用一定会成为大牛的小宋 python 密码学
pypbc是python中使用双线性配对运算的库，在密码学中双线性对是经常使用到的运算。pypbc的安装请参照ubuntu16.04安装pypbc库pypbc中提供了Parameters、Pairing、Element三个类Parameters生成参数：由于是在椭圆曲线上生成的双线性对，PBC库提供了几种不同的曲线，pypbc一般取的是a类曲线，具体参照PBCLibraryManual0.5.14
RC4算法：流密码算法的经典之作 qcidyu 好用的工具集合代码实例演示工作原理详解应用场景介绍 RC4 vs DES性能比较 RC4 vs AES安全性算法优劣分析 RC4起源演变
title:RC4算法：流密码算法的经典之作date:2024/3/1118:16:16updated:2024/3/1118:16:16tags:RC4起源演变算法优劣分析RC4vsAES安全性RC4vsDES性能比较应用场景介绍工作原理详解代码实例演示一、RC4算法的起源与演变RC4算法是由著名密码学家RonRivest在1987年设计的一种流密码算法，其名字来源于RivestCipher4。
SAX解析xml文件小猪猪08 xml
1.创建SAXParserFactory实例 2.通过SAXParserFactory对象获取SAXParser实例 3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 4.SAXParser实例的parse来获取文件 public static void main(String[] args) { //
为什么mysql里的ibdata1文件不断的增长？ brotherlamp linux linux运维 linux资料 linux视频 linux运维自学
我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： ibdata1存了什么？当你启用了 i
Quartz-quartz.properties配置 eksliang quartz
其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。下面是这些默认值的解释 #-----集群的配置 org.quartz.scheduler.instanceName =
informatica session的使用 18289753290 workflow session log Informatica
如果希望workflow存储最近20次的log，在session里的Config Object设置，log options做配置，save session log :sessions run ;savesessio log for these runs:20 session下面的source 里面有个tracing
Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误酷的飞上天空 scrapy
Scrapy版本0.14.4 出现问题现象： ERROR: Error downloading <GET http://xxxxx CRC check failed 解决方法 1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 明确表示不支持任何形式的压缩格式，避免程序的解压
java Swing小集锦永夜-极光 java swing
1.关闭窗体弹出确认对话框 1.1 this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 1.2 this.addWindowListener ( new WindowAdapter () { public void windo
强制删除.svn文件夹随便小屋 java
在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
GET和POST有什么区别？及为什么网上的多数答案都是错的。 aijuans get post
如果有人问你，GET和POST，有什么区别？你会如何回答？我的经历前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
谈谈新浪微博背后的那些算法 aoyouzi 谈谈新浪微博背后的那些算法
本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
Connection reset 连接被重置的解决方法百合不是茶 java 字符流连接被重置
流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置被重置的代码如下; 客户端代码; package 通信软件服务器; import java.io.BufferedWriter; import java.io.OutputStream; import java.io.O
web.xml配置详解之filter bijian1013 java web.xml filter
一.定义 <filter> <filter-name>encodingfilter</filter-name> <filter-class>com.my.app.EncodingFilter</filter-class> <init-param> <param-name>encoding<
Heritrix Bill_chen 多线程 xml 算法制造配置管理
作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
【Zookeeper】FAQ bit1129 zookeeper
1.脱离IDE，运行简单的Java客户端程序 #ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient 1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 2. 如果Zookeeper集群跨越多个机房，那么Leader/
The user specified as a definer ('aaa'@'localhost') does not exist 白糖_ localhost
今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 最后找原因发现删除操作做了触发器，而触发器里面有这样一句 /*!50017 DEFINER = ''aaa@'localhost' */ 原来最初
javascript中showModelDialog刷新父页面 bozch JavaScript 刷新父页面 showModalDialog
在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 在子页面使用w
编程之美-买书折扣 bylijinnan 编程之美
import java.util.Arrays; public class BookDiscount { /**编程之美买书折扣书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。下面用动态规划实现。哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要 chenbowen00 struts WEB安全
因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。下面记录下本次解决的过程以便后续 1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议，而使用ftp协议默认会产生一个匿名用
[电力与暖气]煤炭燃烧与电力加温 comsci
在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? &nbs
oracle O7_DICTIONARY_ACCESSIBILITY参数 daizj oracle
O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
比较全面的MySQL优化参考 dengkane mysql
本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 1、硬件层相关优化 1.1、CPU相关在服务器的BIOS设置中，可
C语言homework2，有一个逆序打印数字的小算法 dcj3sjt126com c
#h1# 0、完成课堂例子 1、将一个四位数逆序打印 1234 ==> 4321 实现方法一： # include <stdio.h> int main(void) { int i = 1234; int one = i%10; int two = i / 10 % 10; int three = i / 100 % 10;
apacheBench对网站进行压力测试 dcj3sjt126com apachebench
ab 的全称是 ApacheBench ，是 Apache 附带的一个小工具，专门用于 HTTP Server 的 benchmark testing ，可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。
2种办法让HashMap线程安全 flyfoxs java jdk jni
多线程之--2种办法让HashMap线程安全多线程之--synchronized 和reentrantlock的优缺点多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.
Spring Security（04）——认证简介 234390216 Spring Security 认证过程
认证简介目录 1.1 认证过程 1.2 Web应用的认证过程 1.2.1 ExceptionTranslationFilter 1.2.2 在request之间共享SecurityContext 1
Java 位运算 Javahuhui java 位运算
// 左移( << ) 低位补0 // 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： // 0000 0000 0000 0000 0000 0000 0001 1000 System.out.println(6 << 2);// 运行结果是24 // 右移( >> ) 高位补"
mysql免安装版配置 ldzyz007 mysql
1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 3、my-large.ini是为专用于一个SQL数据
MFC和ado数据库使用时遇到的问题你不认识的休道人 sql C++mfc
=================================================================== 第一个 =================================================================== try{ CString sql; sql.Format("select * from p
表单重复提交Double Submits rensanning double
可能发生的场景： *多次点击提交按钮 *刷新页面 *点击浏览器回退按钮 *直接访问收藏夹中的地址 *重复发送HTTP请求（Ajax）（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： http://getbootstrap.co
Java String 十大常见问题 tomcat_oracle java 正则表达式
　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。　　equals()判断两个字符串的值是否相等。　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。　　
SpringMVC 登陆拦截器实现登陆控制 xp9802 springMVC
思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。实现方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

DES与AES实现

你可能感兴趣的:(密码学)