SMS4 algoritms, kas ir simetrisks bloku kriptogrāfijas algoritms

Xiaoweier · Publicēts 08.12.2015 21:49:35

Tas ir bloku kriptogrāfijas algoritms, bet viņš izmanto daudz lietu, un tagad internetā ir īpašs avota kods, bet šim kodam joprojām ir noteikta pētniecības vērtība, ja jūs arī interesē, jūs varat ienākt un sazināties un mācīties kopā. Patiesībā nav jēgas dot jums pilnu kodu, bet es joprojām pievienoju pilnu koda adresi http://www.2cto.com/kf/201501/369374.html
Tajā ir arī S lodziņš, kas ir ļoti svarīgs, kas tiek izmantots DES algoritmā, tāpēc mana kolēģa ieteikums man ir skaidri saprast DES algoritma S lodziņu, lai es varētu zināt, par ko runā šī SMS4 algoritma specifikācija? Specifikācija nav pievienota.

Maz putas · Publicēts 08.12.2015 22:19:05

SMS4 ievads:

Šis algoritms ir grupēšanas algoritms. Algoritma paketes garums ir 128 biti un atslēgas garums ir 128 biti, kas ir 16 baiti. Gan šifrēšanas algoritms, gan atslēgas paplašināšanas algoritms pieņem 32 kārtu nelineāru iterācijas struktūru. Atšifrēšanas algoritmam ir tāda pati struktūra kā šifrēšanas algoritmam, izņemot to, ka apaļās atslēgas izmantošanas secība ir apgriezta, un atšifrēšanas riteņa atslēga ir šifrēšanas riteņa atslēgas apgrieztā secība. Visās SMS4 bāzes klasēs jūs redzēsiet, ka šifrēšanas un atšifrēšanas pamatfunkcijas ir vienādas, bet, lai noteiktu, vai tas ir šifrēts vai atšifrēts, ir nepieciešams int tipa karodziņa bits.

SMS4 šifrēšanas algoritma pamati:

publiskā klase SMS4 {

privātais statiskais galīgais int ENCRYPT = 1;
privāts statisks galīgais int DECRYPT = 0;
publiskais statiskais fināls int ROUND = 32;
privātais statiskais galīgais int BLOCK = 16;

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

privāts int[] CK = { 0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
         0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9, 0xe0e7eef5,
         0xfc030a11, 0x181f262d, 0x343b4249, 0x50575e65, 0x6c737a81,
         0x888f969d, 0xa4abb2b9, 0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d,
         0x141b2229, 0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
         0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209, 0x10171e25,
         0x2c333a41, 0x484f565d, 0x646b7279 };

private int Rotl(int x, int y) {
      atdeve x << gadā | x >>> (32 - gadi);
}

private int ByteSub(int A) {
      atgriešanās (Sbox[A >>> 24 & 0xFF] & 0xFF) << 24
            | (Sbox[A >>> 16 & 0xFF] & 0xFF) << 16
            | (Sbox[A >>> 8 & 0xFF] & 0xFF) << 8 | (Sbox[A & 0xFF] & 0xFF);
}

privāts int L1 (int B) {
      atgriešanās B ^ Rotl(B, 2) ^ Rotl(B, 10) ^ Rotl(B, 18) ^ Rotl(B, 24);
      atgriezt B^(B<<2|B>>>30)^(B<<10|B>>>22)^(B<<18|B>>>14)^(B<<24|B>>>8);
}

privāts int L2 (int B) {
      atgriezties B ^ Rotl(B, 13) ^ Rotl(B, 23);
      atgriezties B^(B<<13|B>>>19)^(B<<23|B>>>9);
}

void SMS4Crypt(baits[] Ievade, baits[] Izeja, int[] rk) {
      int r, vid, x0, x1, x2, x3;
      int[] x = jauns int[4];
      int[] tmp = jauns int[4];
      for (int i = 0; I < 4; i++) {
         tmp[0] = Ievade[0 + 4 * i] & 0xff;
         tmp[1] = Ievade[1 + 4 * i] & 0xff;
         tmp[2] = Ievade[2 + 4 * i] & 0xff;
         tmp[3] = Ievade[3 + 4 * i] & 0xff;
         x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
         x=(Ievade[0+4*i]<<24| Ievade[1+4*i]<<16| Ievade[2+4*i]<<8| Ievade[3+4*i]);
      }
      par (r = 0; r < 32; r += 4) {
         mid = x[1] ^ x[2] ^ x[3] ^ rk[r + 0];
         mid = ByteSub(vidū);
         x[0] = x[0] ^ L1(vidū); x4

         mid = x[2] ^ x[3] ^ x[0] ^ rk[r + 1];
         mid = ByteSub(vidū);
         x[1] = x[1] ^ L1(vidus); x5

         mid = x[3] ^ x[0] ^ x[1] ^ rk[r + 2];
         mid = ByteSub(vidū);
         x[2] = x[2] ^ L1(vidū); x6

         mid = x[0] ^ x[1] ^ x[2] ^ rk[r + 3];
         mid = ByteSub(vidū);
         x[3] = x[3] ^ L1(vidū); x7
      }

      Reverss
      for (int j = 0; J < 16; j += 4) {
         Izeja[j] = (baits) (x[3 - j / 4] >>> 24 & 0xFF);
         Izeja[j + 1] = (baits) (x[3 - j / 4] >>> 16 & 0xFF);
         Izeja[j + 2] = (baits) (x[3 - j / 4] >>> 8 & 0xFF);
         Izeja[j + 3] = (baits) (x[3 - j / 4] & 0xFF);
      }
}

private void SMS4KeyExt(byte[] Key, int[] rk, int CryptFlag) {
      int r, vidus;
      int[] x = jauns int[4];
      int[] tmp = jauns int[4];
      for (int i = 0; I < 4; i++) {
         tmp[0] = Atslēga[0 + 4 * i] & 0xFF;
         tmp[1] = atslēga[1 + 4 * i] & 0xff;
         tmp[2] = Atslēga[2 + 4 * i] & 0xff;
         tmp[3] = Atslēga[3 + 4 * i] & 0xff;
         x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
         x=Atslēga[0+4*i]<<24| Atslēga[1+4*i]<<16| Atslēga[2+4*i]<<8| Atslēga[3+4*i];
      }
      x[0] ^= 0xa3b1bac6;
      x[1] ^= 0x56aa3350;
      x[2] ^= 0x677d9197;
      x[3] ^= 0xb27022dc;
      par (r = 0; r < 32; r += 4) {
         mid = x[1] ^ x[2] ^ x[3] ^ CK[r + 0];
         mid = ByteSub(vidū);
         rk[r + 0] = x[0] ^= L2(vidus); rk0=K4

         mid = x[2] ^ x[3] ^ x[0] ^ CK[r + 1];
         mid = ByteSub(vidū);
         rk[r + 1] = x[1] ^= L2(vidus); rk1=K5

         mid = x[3] ^ x[0] ^ x[1] ^ CK[r + 2];
         mid = ByteSub(vidū);
         rk[r + 2] = x[2] ^= L2(vidus); rk2=K6

         mid = x[0] ^ x[1] ^ x[2] ^ CK[r + 3];
         mid = ByteSub(vidū);
         rk[r + 3] = x[3] ^= L2(vidus); rk3=K7
      }

      Atšifrējiet riteņa atslēgas secību: rk31, rk30,...,rk0
      if (CryptFlag == DECRYPT) {
         par (r = 0; r < 16; r++) {
            mid = rk[r];
            rk[r] = rk[31 - r];
            rk[31 - r] = vidēji;
         }
      }
}

public int sms4(byte[] in, int inLen, byte[] key, byte[] out, int CryptFlag) {
      int punkts = 0;
      int[] round_key = jauns int[ROUND];
      int[] round_key={0};
      SMS4KeyExt(atslēga, round_key, CryptFlag);
      baits[] ievade = jauns baits[16];
      baits[] izvade = jauns baits[16];

      kamēr (inLen >= BLOKS) {
         ievade = Arrays.copyOfRange(in, punkts, punkts + 16);
         output=Arrays.copyOfRange(out, punkts, punkts+16);
         SMS4Crypt(ievade, izeja, round_key);
         System.arraycopy(izeja, 0, izeja, punkts, BLOKS);
         inLen -= BLOKS;
         punkts += BLOKS;
      }

      atgriešanās 0;
}
}

Iepakots ārējais interfeiss:

Pamatojoties uz šo pamatklasi, galvenās saskarnes ir šādas:

privātais statiskais baits[] encode16(baits[] vienkāršs, baits[] atslēga);
privātais statiskais baits [] dekodēt16 (baits [] šifrs, baits [] atslēga);
privātais statiskais baits [] encode32 (baits [] vienkāršs, baits [] atslēga);
privātais statiskais baits[] decode32(baits[] šifrs, baits[] atslēga);
publiskais statiskais baits[] kodētSMS4(baits[] vienkāršs, baits[] atslēga);
publiskais statiskais baits[] dekodētSMS4(baits[] šifrs, baits[] atslēga);
publiskais statiskais virknes dekodēšanaSMS4toString(baits[] šifrs, baits[] atslēga);

encode16(byte[], byte[]) ir interfeiss šifrēšanai 16 bitu vienkārša teksta un 16 bitu atslēgām;
privātais statiskais baits [] decode16 (baits [] šifrs, baits [] atslēga): ir interfeiss 16 bitu šifrēta teksta un 16 bitu atslēgas atšifrēšanai;
private static byte[] encode32(byte[] plain, byte[] key): Šis ir interfeiss, kas šifrē 32 bitu vienkārša teksta un 16 bitu atslēgas.
private static byte[] decode32(byte[] cipher, byte[] key): Šis ir interfeiss 32 bitu šifrēta teksta un 16 bitu atslēgu atšifrēšanai.
publiskais statiskais baits [] kodētSMS4 (baits [] vienkāršs, baits [] atslēga): Šis ir interfeiss, kas šifrē vienkārša teksta un 16 bitu atslēgas ar neierobežotu baitu skaitu.
publiskais statiskais baits [] dekodētSMS4 (baits [] šifrs, baits [] atslēga): Šis ir interfeiss šifrēta teksta un 16 bitu atslēgu atšifrēšanai ar neierobežotu baitu skaitu.
publiskā statiskā virknes dekodēšanaSMS4toString(baits[] šifrs, baits[] atslēga): Šis ir interfeiss neierobežotu šifrēta teksta baitu un 16 bitu atslēgu atšifrēšanai.
Interfeisa metodes kods:

publiskais statiskais baits [] kodētSMS4 (Virkne vienkāršs teksts, baits[] atslēga) {
      if (vienkāršs teksts == null || vienkāršs teksts.vienāds()) {
         atgriezt null;
      }
      for (int i = plaintext.getBytes().length % 16; I < 16; i++) {
         vienkāršs teksts += '';
      }

      atgriezt SMS4.encodeSMS4(plaintext.getBytes(), key);
}

/**
   * SMS4 šifrēšana ar neierobežotu vienkārša teksta garumu
   *
   * @param vienkāršs teksts
   * @param atslēga
   * @return
   */
publiskais statiskais baits[] encodeSMS4(baits[] vienkāršs teksts, baits[] atslēga) {
      baits[] šifrēts teksts = jauns baits [vienkāršs teksts.garums];

      int k = 0;
      int plainLen = vienkāršs teksts.garums;
      kamēr (k + 16 <= plainLen) {
         baits[] cellPlain = jauns baits[16];
         for (int i = 0; I < 16; i++) {
            cellPlain= vienkāršs teksts[k + i];
         }
         baits[] cellCipher = encode16(cellPlain, atslēga);
         for (int i = 0; i < cellCipher.length; i++) {
            šifrēts teksts[k + i] = cellCipher;
         }

         k += 16;
      }

      atgriezt šifrētu tekstu;
}

/**
   * SMS4 atšifrēšana bez vienkārša teksta garuma ierobežojuma
   *
   * @param šifrēts teksts
   * @param atslēga
   * @return
   */
publiskais statiskais baits[] dekodētSMS4(baits[] šifrēts teksts, baits[] atslēga) {
      baits[] vienkāršs teksts = jauns baits [šifrēts.garums];

      int k = 0;
      int cipherLen = ciphertext.length;
      kamēr (k + 16 <= cipherLen) {
         baits[] cellCipher = jauns baits[16];
         for (int i = 0; I < 16; i++) {
            cellCipher= šifrēts teksts[k + i];
         }
         baits[] cellPlain = dekodēt16(cellCipher, atslēga);
         for (int i = 0; i < cellPlain.length; i++) {
            vienkāršs teksts[k + i] = cellPlain;
         }

         k += 16;
      }

      atgriezt vienkāršu tekstu;
}

/**
   * Atšifrēt, lai iegūtu vienkārša teksta virknes
   * @param šifrēts teksts
   * @param atslēga
   * @return
   */
publiskā statiskā virkne dekodēšanaSMS4toString(baits[] šifrēts teksts, baits[] atslēga) {
      baits[] vienkāršs teksts = jauns baits [šifrēts.garums];
      vienkāršs teksts = dekodētSMS4 (šifrēts teksts, atslēga);
      atgriezt jaunu virkni(vienkāršs teksts);
}

/**
   * Šifrēts ir tikai 16 bitu vienkāršs teksts
   *
   * @param vienkāršs teksts
   * @param atslēga
   * @return
   */
privāts statisks baits [] encode16 (baits [] vienkāršs teksts, baits [] atslēga) {
      baits[] šifrs = jauns baits [16];
      SMS4 sm4 = jauns SMS4();
      sm4.sms4(vienkāršs teksts, 16, atslēga, šifrs, ŠIFRĒT);

      atgriešanas šifrs;
}

/**
   * Tiek atšifrēts tikai 16 bitu šifrēts teksts
   *
   * @param vienkāršs teksts
   * @param atslēga
   * @return
   */
privātais statiskais baits[] decode16(baits[] šifrēts teksts, baits[] atslēga) {
      baits[] vienkāršs = jauns baits [16];
      SMS4 sm4 = jauns SMS4();
      sm4.sms4 (šifrēts teksts, 16, atslēga, vienkāršs, ATŠIFRĒT);

      atgriezties vienkāršā;
}
Es šeit neieviesīšu tikai 32 bitu vienkārša teksta šifrēšanu, kas ir ļoti līdzīga tikai 16 bitu vienkārša teksta metodei.

Šifrēšanas un atšifrēšanas pamatalgoritms, neierobežojot vienkārša teksta garumu, ir balstīts uz šifrēšanu un atšifrēšanu tikai 16 bitiem. Vienkāršam tekstam, kas lielāks par 16 bitiem, šeit tiek izmantota pakešu šifrēšana. Ja jūs saskaraties ar vienkāršu tekstu, piemēram, 30 bitiem, kurus nevar dalīt ar 16, veids, kā to aizpildīt, ir izveidot to, līdz tas ir dalāms ar 16. Principā tikai mazāko skaitli var dalīt ar 16, protams, ja esat laimīgs, nav svarīgi, vai jūs to padarāt lielāku, jo tas ir noslēguma simbols.

Pakešu šifrēšana ir katra 16 bitu vienkārša teksta šifrēšana vienu reizi un pēc tam šifrētā 16 bitu šifrētā teksta atkārtota salikšana jaunā šifrētā tekstā. Atšifrēšanas procesā tas tiek sadalīts arī vienā 16 bitu gabalā, un pēc tam vairāki no šiem atšifrētajiem vienkāršajiem tekstiem tiek atkārtoti salikti jaunā vienkāršā tekstā.

Lietošanas demonstrācija:

atslēga
      baits[] taustiņš = { 0x01, 0x23, 0x45, 0x67, (baits) 0x89, (baits) 0xab,
            (baits) 0xcd, (baits) 0xef, (baits) 0xfe, (baits) 0xdc,
            (baits) 0xba, (baits) 0x98, 0x76, 0x54, 0x32, 0x10 };

      Virkne newString = Kodēšana, sveiki!; Vienkāršs teksts

      baits[] enOut = SMS4.encodeSMS4(jaunaVirkne, atslēga);
      if (enOut == null) {
         atgriezt;
      }

      System.out.println(šifrēšanas rezultāts:);
      printBit(enOut);

      baits[] deOut = SMS4.decodeSMS4(enOut, atslēga);
      System.out.println(
atšifrēšanas rezultāts (atgrieztais baits[]) :);
      printBit(deOut);

      Virkne deOutStr = SMS4.decodeSMS4toString(enOut, atslēga);
      System.out.println(
Atšifrējiet rezultātu (atgriezt virkni):
+ deOutStr);

Xiaoweier · Publicēts 08.12.2015 22:25:41

Xiao Zhazha Publicēts 2015-12-8 22:19
SMS4 ievads:

Šis algoritms ir grupēšanas algoritms. Algoritma paketes garums ir 128 biti un atslēgas garums ir 128 biti, kas ir 16 baiti. ...

Vai jūs kopējat seju iekšā? Es vairākas reizes esmu palaidis šo algoritmu datorā, bet es joprojām neesmu pazīstams ar C # Java atkļūdošanā, un, iespējams, es nezinu katru viņa soli detalizēti, un es vēl neesmu izdomājis viņa darba detaļu principu. Java, zināt, kā atkļūdot katru tā mainīgo?

Maz putas · Publicēts 08.12.2015 22:40:48

Tam vajadzētu būt pārtraukuma punkta iestatīšanai, myeclipse breakpoint F5 taustiņš un F6 taustiņš ir viena soļa atkļūdošana, F5 ir solis, tas ir, ievadiet izpildāmo rindas kodu, F6 ir solis, tas ir, izpildiet rindas kodu, pāriet uz nākamo rindu

Xiaoweier · Publicēts 08.12.2015 23:07:37

Publicēts 2015-12-8 22:40
Tam vajadzētu būt pārtraukuma punkta iestatīšanai, myeclipse breakpoint F5 taustiņš un F6 taustiņš ir viena soļa atkļūdošana, F5 ir solis, tas ir, ievadiet šīs rindas kodu, lai izpildītu ...

Es noteikti zinu, bet es nezinu viņa konkrēto procesu, un es nezinu, kad un kur es nonākšu pie kāda specifikācijas soļa. Būtu jauki, ja jūs saprastu

[Algoritms] SMS4 algoritms, kas ir simetrisks bloku kriptogrāfijas algoritms

Skatītās sadaļas