c语言中133%10=?

我不确定您的问题是什么，因为您使用了无法识别的非标准字符。如果您使用标准 ASCII 字符，那么133可能代表字符码表中的某个字符，或者是数字133本身。但是，由于您的问题属于技术问题，我可以回答：133在 C 语言中可以代表一个整数值。

相关问题

写一个C语言额AES加密函数

好的，我可以帮您写一个C语言的AES加密函数，以下是代码：

#include <stdio.h>
#include <string.h>
#include <stdint.h>

#define AES_BLOCK_SIZE 16

typedef struct {
  uint32_t rk[60];
  int nr;
} aes_key_t;

static const uint8_t sbox[256] = {
   99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 118,
  202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
  183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113, 216,  49,  21,
    4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,
    9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,  47, 132,
   83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,  57,  74,  76,  88, 207,
  208, 239, 170, 251,  67,  77,  51, 133,  69, 249,   2, 127,  80,  60, 159, 168,
   81, 163,  64, 143, 146, 157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210,
  205,  12,  19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25, 115,
   96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20, 222,  94,  11, 219,
  224,  50,  58,  10,  73,   6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121,
  231, 200,  55, 109, 141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8,
  186, 120,  37,  46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,
  112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158,
  225, 248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223,
  140, 161, 137,  13, 191, 230,  66, 104,  65, 153,  45,  15, 176,  84, 187,  22,
};

static const uint8_t rcon[11] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36, 0x6C };

static void aes_sub_bytes(uint8_t* state) {
  uint32_t i;
  for (i = 0; i < AES_BLOCK_SIZE; ++i) {
    state[i] = sbox[state[i]];
  }
}

static void aes_shift_rows(uint8_t* state) {
  uint32_t tmp;

  // Row 0 does not change
  // Shift row 1
  tmp = state[1];
  state[1] = state[5];
  state[5] = state[9];
  state[9] = state[13];
  state[13] = tmp;

  // Shift row 2
  tmp = state[2];
  state[2] = state[10];
  state[10] = tmp;
  tmp = state[6];
  state[6] = state[14];
  state[14] = tmp;

  // Shift row 3
  tmp = state[15];
  state[15] = state[11];
  state[11] = state[7];
  state[7] = state[3];
  state[3] = tmp;
}

static uint8_t gfmul(uint8_t a, uint8_t b) {
  uint32_t sum = 0;
  while (b) {
    if (b & 1) {
      sum ^= a;
    }
    a <<= 1;
    b >>= 1;
    if (a & 0x100) {
      a ^= 0x11B;
    }
  }
  return (uint8_t)sum;
}

static void mix_column(uint8_t* col) {
  uint8_t tmp[4];
  uint32_t i;
  for (i = 0; i < 4; ++i) {
    tmp[i] = col[i];
  }

  col[0] = gfmul(tmp[0], 2) ^ gfmul(tmp[3], 1) ^ gfmul(tmp[2], 1) ^ gfmul(tmp[1], 3);
  col[1] = gfmul(tmp[1], 2) ^ gfmul(tmp[0], 1) ^ gfmul(tmp[3], 1) ^ gfmul(tmp[2], 3);
  col[2] = gfmul(tmp[2], 2) ^ gfmul(tmp[1], 1) ^ gfmul(tmp[0], 1) ^ gfmul(tmp[3], 3);
  col[3] = gfmul(tmp[3], 2) ^ gfmul(tmp[2], 1) ^ gfmul(tmp[1], 1) ^ gfmul(tmp[0], 3);
}

static void aes_mix_columns(uint8_t* state) {
  uint32_t i;
  for (i = 0; i < 4; ++i) {
    mix_column(&state[i * 4]);
  }
}

static void aes_add_round_key(uint8_t* state, const uint32_t* key) {
  uint32_t i, j;
  for (i = 0; i < 4; ++i) {
    j = i * 4;
    state[j] ^= (uint8_t)(key[i] >> 24);
    state[j + 1] ^= (uint8_t)(key[i] >> 16);
    state[j + 2] ^= (uint8_t)(key[i] >> 8);
    state[j + 3] ^= (uint8_t)key[i];
  }
}

static void aes_generate_key(const uint8_t* key, aes_key_t* aes_key) {
  uint32_t i, j, k;
  uint32_t temp;
  uint32_t* rk;
  const uint32_t* rc;
  const uint32_t* rcp;

  rk = aes_key->rk;
  aes_key->nr = 10;

  for (i = 0; i < 4; ++i) {
    rk[i] =
      (uint32_t)((key[4 * i] << 24) | (key[4 * i + 1] << 16) | (key[4 * i + 2] << 8) | key[4 * i + 3]);
  }

  rc = rcon;
  rcp = rc++;

  // Generate the next 44 round keys
  for (i = 4; i < 44; ++i) {
    temp = rk[i - 1];
    if (i % 4 == 0) {
      temp = ((uint32_t)sbox[temp & 0xFF]) |
             ((uint32_t)sbox[(temp >> 8) & 0xFF] << 8) |
             ((uint32_t)sbox[(temp >> 16) & 0xFF] << 16) |
             ((uint32_t)sbox[(temp >> 24) & 0xFF] << 24);

      temp ^= (*rcp << 24);
      rcp = (++rcp == rcon + 10) ? rcon : rcp;
    }

    if (i % 4 == 1) {
      temp = ((uint32_t)sbox[temp & 0xFF] << 8) |
             ((uint32_t)sbox[(temp >> 8) & 0xFF] << 16) |
             ((uint32_t)sbox[(temp >> 16) & 0xFF] << 24) |
             ((uint32_t)sbox[(temp >> 24) & 0xFF]);

    }

    rk[i] = rk[i - 4] ^ temp;
  }
}

static void aes_encrypt(const uint8_t* in, uint8_t* out, const aes_key_t* aes_key) {
  uint32_t i, j;
  uint8_t state[AES_BLOCK_SIZE];
  const uint32_t* rk;

  memcpy(state, in, AES_BLOCK_SIZE);
  rk = aes_key->rk;

  aes_add_round_key(state, rk);

  for (i = 1; i < aes_key->nr; ++i) {
    aes_sub_bytes(state);
    aes_shift_rows(state);
    aes_mix_columns(state);
    rk += 4;
    aes_add_round_key(state, rk);
  }

  aes_sub_bytes(state);
  aes_shift_rows(state);
  rk += 4;
  aes_add_round_key(state, rk);

  memcpy(out, state, AES_BLOCK_SIZE);
}

void aes_cbc_encrypt(const uint8_t* iv, const uint8_t* in, uint8_t* out, uint32_t len, const uint8_t* key) {
  aes_key_t aes_key;
  uint8_t buf[AES_BLOCK_SIZE], prev[AES_BLOCK_SIZE];
  uint32_t i, j;
  const uint8_t* p;

  aes_generate_key(key, &aes_key);

  // Encrypt the first block with the IV
  for (i = 0; i < AES_BLOCK_SIZE; ++i) {
    buf[i] = prev[i] = in[i] ^ iv[i];
  }
  aes_encrypt(buf, buf, &aes_key);
  for (i = 0; i < AES_BLOCK_SIZE; ++i) {
    out[i] = buf[i];
  }

  // Encrypt the remaining blocks with CBC
  for (p = in + AES_BLOCK_SIZE, i = AES_BLOCK_SIZE; i < len; p += AES_BLOCK_SIZE, i += AES_BLOCK_SIZE) {
    for (j = 0; j < AES_BLOCK_SIZE; ++j) {
      buf[j] = p[j] ^ prev[j];
    }
    aes_encrypt(buf, buf, &aes_key);
    for (j = 0; j < AES_BLOCK_SIZE; ++j) {
      prev[j] = buf[j];
      out[i + j] = buf[j];
    }
  }
}

int main() {
  uint8_t key[AES_BLOCK_SIZE] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
  uint8_t in[AES_BLOCK_SIZE] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
  uint8_t iv[AES_BLOCK_SIZE] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
  uint8_t out[AES_BLOCK_SIZE];
  
  aes_cbc_encrypt(iv, in, out, AES_BLOCK_SIZE, key);

  for (int i = 0; i < AES_BLOCK_SIZE; i++) {
    printf("%02x ", out[i]);
  }
  
  return 0;
}

3DES加密算法源码 c语言

以下是3DES加密算法的C语言源码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ENCRYPT 1
#define DECRYPT 0

typedef unsigned char BYTE;
typedef unsigned long DWORD;

/* 定义DES算法中使用的数据类型 */
typedef struct {
    BYTE key[8];
    BYTE encrypt;
    BYTE iv[8];
} des_context;

/* 定义3DES算法中使用的数据类型 */
typedef struct {
    des_context des1;
    des_context des2;
    des_context des3;
} des3_context;

/* 定义DES算法中使用的常量 */
static const BYTE odd_parity_table[256] = {
    1, 2, 4, 7, 8, 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31,
    32, 35, 37, 38, 41, 42, 44, 47, 49, 50, 52, 55, 56, 59, 61, 62,
    64, 67, 69, 70, 73, 74, 76, 79, 81, 82, 84, 87, 88, 91, 93, 94,
    97, 98, 100, 103, 104, 107, 109, 110, 112, 115, 117, 118, 121, 122, 124, 127,
    128, 131, 133, 134, 137, 138, 140, 143, 145, 146, 148, 151, 152, 155, 157, 158,
    161, 162, 164, 167, 168, 171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191,
    193, 194, 196, 199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223,
    224, 227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253, 254,
    1, 2, 4, 7, 8, 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31,
    32, 35, 37, 38, 41, 42, 44, 47, 49, 50, 52, 55, 56, 59, 61, 62,
    64, 67, 69, 70, 73, 74, 76, 79, 81, 82, 84, 87, 88, 91, 93, 94,
    97, 98, 100, 103, 104, 107, 109, 110, 112, 115, 117, 118, 121, 122, 124, 127,
    128, 131, 133, 134, 137, 138, 140, 143, 145, 146, 148, 151, 152, 155, 157, 158,
    161, 162, 164, 167, 168, 171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191,
    193, 194, 196, 199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223,
    224, 227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253, 254
};

static const BYTE bytebit[8] = {
    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
};

static const DWORD bigbyte[24] = {
    0x800000L, 0x400000L, 0x200000L, 0x100000L,
    0x080000L, 0x040000L, 0x020000L, 0x010000L,
    0x008000L, 0x004000L, 0x002000L, 0x001000L,
    0x000800L, 0x000400L, 0x000200L, 0x000100L,
    0x000080L, 0x000040L, 0x000020L, 0x000010L,
    0x000008L, 0x000004L, 0x000002L, 0x000001L
};

static const BYTE pc1[56] = {
    56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17, 9, 1,
    58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 62, 54, 46, 38,
    30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 60, 52, 44, 36,
    28, 20, 12, 4, 27, 19, 11, 3
};

static const BYTE totrot[16] = {
    1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28
};

static const BYTE pc2[48] = {
    13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, 22, 18, 11, 3,
    25, 7, 15, 6, 26, 19, 12, 1, 40, 51, 30, 36, 46, 54, 29, 39,
    50, 44, 32, 47, 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31
};

static const DWORD SP1[64] = {
    0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
    0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
    0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
    0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
    0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
    0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
    0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
    0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
    0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
    0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
    0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
    0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
    0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
    0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
    0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
    0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L
};

static const DWORD SP2[64] = {
    0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
    0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
    0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
    0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
    0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
    0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
    0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
    0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
    0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
    0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
    0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
    0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
    0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
    0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
    0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
    0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L
};

static const DWORD SP3[64] = {
    0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
    0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
    0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
    0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
    0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
    0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
    0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
    0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
    0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
    0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
    0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
    0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
    0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
    0x00000008L