SMS4-algoritmi, joka on symmetrinen lohkokryptografian algoritmi

Xiaoweier · Julkaistu 8.12.2015 21.49.35

Tämä on lohkokryptografian algoritmi, mutta hän käyttää monia asioita, ja nyt Internetissä on tietty lähdekoodi, mutta tällä koodilla on silti tietty tutkimusarvo, jos olet kiinnostunut tästäkin, voitte tulla kommunikoimaan ja oppimaan yhdessä. Itse asiassa ei ole järkevää antaa täydellistä koodia, mutta liitän silti koko koodiosoitteen http://www.2cto.com/kf/201501/369374.html
Siinä on myös S-laatikko, joka on erittäin tärkeä ja jota käytetään DES-algoritmissa, joten kollegani ehdotti minulle ymmärtää DES-algoritmin S-laatikko selkeästi, jotta voin tietää, mistä SMS4-algoritmin spesifikaatio puhuu? Määrittelyä ei ole liitetty.

Pikku roisto · Julkaistu 8.12.2015 22.19.05

SMS4-johdanto:

Tämä algoritmi on ryhmittelyalgoritmi. Algoritmin pakettipituus on 128 bittiä ja avaimen pituus 128 bittiä, eli 16 tavua. Sekä salausalgoritmi että avaimen laajennusalgoritmi noudattavat 32-kierrokseista epälineaarista iterointirakennetta. Purkualgoritmilla on sama rakenne kuin salausalgoritmilla, paitsi että pyöreän avaimen käyttöjärjestys on päinvastainen, ja purkupyörän avain on käänteinen järjestys kuin salauspyörän avain. Kaikissa SMS4:n perusluokissa näet, että salauksen ja puron perustoiminnot ovat samat, mutta int-tyypin lippubitti tarvitaan määrittämään, onko se salattu vai purettu.

SMS4-salausalgoritmin perusteet:

julkinen luokka SMS4 {

yksityinen staattinen lopullinen älykkyys ENCRYPT = 1;
yksityinen staattinen lopullinen älykkyys DECRYPT = 0;
julkinen staattinen lopputulos KIERROS = 32;
yksityinen staattinen lopullinen int BLOCK = 16;

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

yksityinen 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) {
      return x << y | x >>> (32 - y);
}

private int ByteSub(int A) {
      return (Sbox[A >>> 24 & 0xFF] & 0xFF) << 24
            | (Sbox[A >>> 16 & 0xFF] & 0xFF) << 16
            | (Sbox[A >>> 8 & 0xFF] & 0xFF) << 8 | (Sbox[A & 0xFF] & 0xFF);
}

private int L1(int B) {
      return B ^ Rotl(B, 2) ^ Rotl(B, 10) ^ Rotl(B, 18) ^ Rotl(B, 24);
      return B^(B<<2|B>>>30)^(B<<10|B>>>22)^(B<<18|B>>>14)^(B<<24|B>>>8);
}

private int L2(int B) {
      return B ^ Rotl(B, 13) ^ Rotl(B, 23);
      return B^(B<<13|B>>>19)^(B<<23|B>>>9);
}

void SMS4Crypt(tavu[] Syöte, tavu[] Ulostulo, int[] rk) {
      int r, mid, x0, x1, x2, x3;
      int[] x = uusi int[4];
      int[] tmp = uusi int[4];
      kun (int i = 0; I < 4; i++) {
         tmp[0] = Syöte[0 + 4 * i] & 0xff;
         tmp[1] = Syöte[1 + 4 * i] & 0xff;
         tmp[2] = Syöte[2 + 4 * i] & 0xff;
         tmp[3] = Syöte[3 + 4 * i] & 0xff;
         x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
         x=(Syöte[0+4*i]<<24| Input[1+4*i]<<16| Input[2+4*i]<<8| syöte[3+4*i]);
      }
      kun (r = 0; r < 32; r += 4) {
         mid = x[1] ^ x[2] ^ x[3] ^ rk[r + 0];
         mid = ByteSub(mid);
         x[0] = x[0] ^ L1(mid); x4

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

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

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

      Kääntöpuoli
      kun (int j = 0; j < 16; j += 4) {
         Output[j] = (tavu) (x[3 - j / 4] >>> 24 & 0xFF);
         Output[j + 1] = (tavu) (x[3 - j / 4] >>> 16 & 0xFF);
         Output[j + 2] = (tavu) (x[3 - j / 4] >>> 8 & 0xFF);
         Output[j + 3] = (tavu) (x[3 - j / 4] & 0xFF);
      }
}

private void SMS4KeyExt(byte[] Key, int[] rk, int CryptFlag) {
      int r, mid;
      int[] x = uusi int[4];
      int[] tmp = uusi int[4];
      kun (int i = 0; I < 4; i++) {
         tmp[0] = Avain[0 + 4 * i] & 0xFF;
         tmp[1] = Key[1 + 4 * i] & 0xff;
         tmp[2] = Key[2 + 4 * i] & 0xff;
         tmp[3] = Key[3 + 4 * i] & 0xff;
         x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
         x=Avain[0+4*i]<<24| Key[1+4*i]<<16| Key[2+4*i]<<8| Key[3+4*i];
      }
      x[0] ^= 0xa3b1bac6;
      x[1] ^= 0x56aa3350;
      x[2] ^= 0x677d9197;
      x[3] ^= 0xb27022dc;
      kun (r = 0; r < 32; r += 4) {
         mid = x[1] ^ x[2] ^ x[3] ^ CK[r + 0];
         mid = ByteSub(mid);
         rk[r + 0] = x[0] ^= L2(mid); rk0=K4

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

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

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

      Pura pyörän avaimen järjestys: rk31, rk30,...,rk0
      if (CryptFlag == DECRYPT) {
         kun (r = 0; r < 16; r++) {
            mid = rk[r];
            rk[r] = rk[31 - r];
            rk[31 - r] = mid;
         }
      }
}

public int sms4(byte[] in, int inLen, byte[] key, byte[] out, int CryptFlag) {
      int piste = 0;
      int[] round_key = uusi int[ROUND];
      int[] round_key={0};
      SMS4KeyExt(avain, round_key, CryptFlag);
      tavu[] input = uusi tavu[16];
      byte[] output = uusi tavu[16];

      while (inLen >= BLOCK) {
         input = Arrays.copyOfRange(in, point, point + 16);
         output=Arrays.copyOfRange(ulos, piste, piste+16);
         SMS4Crypt (syöttö, ulostulo, round_key);
         System.arraycopy (ulostulo, 0, ulos, piste, LOHKO);
         inLen -= BLOKKI;
         piste += BLOKKI;
      }

      palautus 0;
}
}

Paketoitu ulkoinen liitäntä:

Tämän perusluokan perusteella päärajapinnat ovat seuraavat:

yksityinen staattinen tavu[] encode16(tavu[] tavallinen, tavu[] avain);
yksityinen staattinen tavu[] decode16(tavu[] salaus, tavu[] avain);
yksityinen staattinen tavu[] encode32(tavu[] tavallinen, tavu[] avain);
yksityinen staattinen tavu[] decode32(tavu[] salaus, tavu[] avain);
julkinen staattinen tavu[] encodeSMS4(tavu[] tavallinen, tavu[] avain);
julkinen staattinen tavu[] dekoodaa SMS4(tavu[] salaus, tavu[] avain);
julkinen staattinen merkkijonon dekoodausSMS4toString(tavu[] salakirjoitus, tavu[] avain);

encode16(tavu[], tavu[]) on rajapinta 16-bittisten selvätekstin ja 16-bittisten avainten salaukseen;
yksityinen staattinen tavu[] decode16(tavu[] salakirjoitus, tavu[] avain): on rajapinta 16-bittisen salatekstin ja 16-bittisen avaimen purkamiseen;
yksityinen staattinen tavu[] encode32(tavu[] tavallinen, tavu[] avain): Tämä on rajapinta, joka salaa 32-bittiset ja 16-bittiset avaimet.
yksityinen staattinen tavu[] decode32(tavu[] salakirjoitus, tavu[] avain): Tämä on rajapinta 32-bittisten salatekstin ja 16-bittisten avainten purkamiseen.
julkinen staattinen tavu[] encodeSMS4(tavu[] tavallinen, tavu[] avain): Tämä on rajapinta, joka salaa selväkieliset ja 16-bittiset avaimet rajattomalla määrällä tavuja.
julkinen staattinen tavu[] dekoodausSMS4(tavu[] salaus, tavu[] avain): Tämä on rajapinta salatun tekstin ja 16-bittisten avainten purkamiseen, joissa on rajaton määrä tavuja.
julkinen staattinen merkkijonon dekoodausSMS4toString(tavu[] salakirjoitus, tavu[] avain): Tämä on rajapinta rajattomasti salatun tekstin tavujen ja 16-bittisten avainten purkamiseen.
Rajapintamenetelmän koodi:

julkinen staattinen tavu[] encodeSMS4(Merkkijono, tavu[] avain) {
      if (selväkieli == null || selväteksti.equals()) {
         return null;
      }
      for (int i = plaintext.getBytes().length % 16; I < 16; i++) {
         selvä teksti += '';
      }

      palauta SMS4.encodeSMS4(plaintext.getBytes(), avain);
}

/**
   * SMS4-salaus rajattomalla selväkielisellä pituudella
   *
   * @param selvä teksti
   * @param avain
   * @return
   */
julkinen staattinen tavu[] encodeSMS4(tavu[] selvä teksti, tavu[] avain) {
      byte[] ciphertext = uusi tavu[plaintext.length];

      int k = 0;
      int plainLen = selvä teksti.pituus;
      kun (k + 16 <= plainLen) {
         byte[] cellPlain = uusi tavu[16];
         kun (int i = 0; I < 16; i++) {
            cellPlain= selvä teksti[k + i];
         }
         byte[] cellCipher = encode16(cellPlain, key);
         kun (int i = 0; i < cellCipher.length; i++) {
            salateksti[k + i] = cellCipher;
         }

         k += 16;
      }

      salatun tekstin palautus;
}

/**
   * SMS4-salauksen purku ilman rajoitusta selvätekstin pituudelle
   *
   * @param salattu teksti
   * @param avain
   * @return
   */
julkinen staattinen tavu[] dekoodausSMS4(tavu[] salakirjoitus, tavu[] avain) {
      byte[] plaintext = uusi tavu[ciphertext.length];

      int k = 0;
      int cipherLen = ciphertext.pituus;
      kun (k + 16 <= cipherLen) {
         byte[] cellCipher = uusi tavu[16];
         kun (int i = 0; I < 16; i++) {
            cellCipher= salattu teksti[k + i];
         }
         byte[] cellPlain = decode16(cellCipher, avain);
         kun (int i = 0; i < cellPlain.length; i++) {
            selvä teksti[k + i] = cellPlain;
         }

         k += 16;
      }

      palauttaa selvä teksti;
}

/**
   * Purkaa salaus saadakseen selväkieliset merkkijonot
   * @param salattu teksti
   * @param avain
   * @return
   */
julkinen staattinen Merkkijonon dekoodausSMS4toString(tavu[] salateksti, tavu[] avain) {
      byte[] plaintext = uusi tavu[ciphertext.length];
      selvä teksti = dekoodaa SMS4 (salateksti, avain);
      return new String (selväkieli);
}

/**
   * Vain 16-bittinen selväkieli on salattu
   *
   * @param selvä teksti
   * @param avain
   * @return
   */
yksityinen staattinen tavu[] encode16(tavu[] selvä teksti, tavu[] avain) {
      tavu[] cipher = uusi tavu[16];
      SMS4 sm4 = uusi SMS4();
      sm4.sms4(selväkieli, 16, avain, salaus, SALAUS);

      paluusalakirjoitus;
}

/**
   * Vain 16-bittinen salattu teksti puretaan
   *
   * @param selvä teksti
   * @param avain
   * @return
   */
yksityinen staattinen tavu[] decode16(tavu[] salateksti, tavu[] avain) {
      tavu[] plain = uusi tavu[16];
      SMS4 sm4 = uusi SMS4();
      sm4.sms4(salakirjoitus, 16, avain, tavallinen, PURKU);

      palaa selvästi;
}
En aio tässä esitellä pelkästään 32-bittistä selväkielistä salausta, joka on hyvin samankaltainen kuin pelkkä 16-bittinen selväkielinen menetelmä.

Perusalgoritmi salaukseen ja purkuun, ilman että selväkielisen tekstin pituutta rajoitetaan, perustuu siihen, että salataan ja puretaan vain 16 bittiä. Yli 16-bittisille selväkielisille käytettiin pakettisalausta tässä. Jos kohtaat selvätekstiä kuten 30 bittiä, jota ei voi jakaa 16:lla, tapa täyttää se on korvata se, kunnes se on jaollinen 16:lla. Periaatteessa vain pienin luku voidaan jakaa 16:lla, tietenkin, jos olet tyytyväinen, ei ole väliä, jos siitä tulee suurempi, koska se on päätössymboli.

Pakettisalaus tarkoittaa, että jokainen 16-bittinen selväkieli salataan kerran ja sitten kootaan salattu 16-bittinen salateksti uudelleen uudeksi salatekstiksi. Purkuprosessissa se jaetaan myös yhdeksi 16-bittiseksi osaksi, ja useat näistä puretuista selväkielistä kootaan uudelleen uudeksi selväksi tekstiksi.

Käytön esittely:

Avain
      tavu[] avain = { 0x01, 0x23, 0x45, 0x67, (tavu) 0x89, (tavu) 0xab,
            (tavu) 0xcd, (tavu) 0xef, (tavu) 0xfe, (tavu) 0xdc,
            (tavu) 0xba, (tavu) 0x98, 0x76, 0x54, 0x32, 0x10 };

      String newString = Koodaus, hei!; Selvä teksti

      byte[] enOut = SMS4.encodeSMS4(newString, key);
      if (enOut == null) {
         paluu;
      }

      System.out.println (salaustulos:);
      printBit(enOut);

      byte[] deOut = SMS4.decodeSMS4(enOut, key);
      System.out.println(
purkutulos (palautustavu[]) :);
      printBit(deOut);

      Merkkijono deOutStr = SMS4.decodeSMS4toString(enOut, avain);
      System.out.println(
Pura tulos (return String):
+ deOutStr);

Xiaoweier · Julkaistu 8.12.2015 22.25.41

Xiao Zhazha Julkaistu 2015-12-8 22:19
SMS4-johdanto:

Tämä algoritmi on ryhmittelyalgoritmi. Algoritmin pakettipituus on 128 bittiä ja avaimen pituus 128 bittiä, eli 16 tavua. ...

Kopioitko kasvot sisällä? Olen ajanut tätä algoritmia tietokoneella useita kertoja, mutta en ole vielä perehtynyt C#:aan Java-debuggauksessa, enkä välttämättä tunne hänen jokaista vaihettaan yksityiskohtaisesti, enkä ole vielä ymmärtänyt hänen työnsä yksityiskohtien periaatetta. Java, osaatko debugata jokaisen muuttujan?

Pikku roisto · Julkaistu 8.12.2015 22.40.48

Sen pitäisi olla katkopisteen asettaminen, myeclipse breakpoint F5 ja F6 -näppäin ovat yksivaiheista debuggausta, F5 on step into, eli syötä rivikoodi suoritettavaksi, F6 on step over, eli suorita rivikoodi, hyppää seuraavalle riville

Xiaoweier · Julkaistu 8.12.2015 23.07.37

Julkaistu 2015-12-8 klo 22:40
Sen pitäisi olla katkopisteen asettaminen, myclipse breakpoint F5 -näppäin ja F6-näppäin ovat molemmat yksivaiheista debuggausta, F5 on step in, eli syötä tämän rivin koodi suorittaaksesi ...

Tiedän varmasti, mutta en tiedä hänen tarkkaa prosessiaan, enkä tiedä milloin ja missä pääsen mihin vaiheeseen määrittelyssä. Olisi mukavaa, jos ymmärtäisit

[Algoritmi] SMS4-algoritmi, joka on symmetrinen lohkokryptografian algoritmi

Katsotut osuudet