SMS4 algoritm, mis on sümmeetriline plokkkrüptograafia algoritm

Xiaoweier · Postitatud 08.12.2015 21:49:35

See on plokkkrüptograafia algoritm, aga ta kasutab palju erinevaid asju, ja nüüd on internetis konkreetne lähtekood, kuid sellel koodil on siiski teatud uurimisväärtus, kui sind see huvitab, võid tulla suhelma ja koos õppima. Tegelikult pole mõtet anda sulle täielikku koodi, aga ma lisan ikkagi täieliku koodiaadressi http://www.2cto.com/kf/201501/369374.html
Seal on ka S-kast, mis on väga oluline ja mida kasutatakse DES-algoritmis, seega minu kolleegi soovitus on mõista DES-algoritmi S-kasti selgelt, et ma saaksin aru, millest SMS4 algoritmi spetsifikatsioon räägib? Spetsifikatsioon ei ole lisatud.

Väike sodi · Postitatud 08.12.2015 22:19:05

SMS4 sissejuhatus:

See algoritm on grupeerimisalgoritm. Algoritmil on paketi pikkus 128 bitti ja võtme pikkus 128 bitti, mis on 16 baiti. Nii krüpteerimisalgoritm kui ka võtme laiendamise algoritm kasutavad 32-voorulist mittelineaarset iteratsioonistruktuuri. Dekrüpteerimisalgoritmil on sama struktuur mis krüpteerimisalgoritmil, välja arvatud see, et ringvõtme kasutusjärjekord on vastupidine ning dekrüpteerimisratta võti on vastupidine krüpteerimisratta võtme järjekord. Kõigis SMS4 baasklassides näete, et krüpteerimise ja dekrüpteerimise baasfunktsioonid on samad, kuid selleks, et määrata, kas see on krüpteeritud või dekrüpteeritud, on vaja int-tüüpi lipubitti.

SMS4 krüpteerimisalgoritmi alused:

avalik klass SMS4 {

privaatne staatiline lõplik intellekt KRÜPTEERIMINE = 1;
privaatne staatiline lõplik intellekt DEKRÜPTEERIMINE = 0;
avalik staatiline lõppint VOOR = 32;
privaatne staatiline lõplik intellekt BLOCK = 16;

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

privaatne 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) {
      tagasta 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) {
      tagasi 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) {
      tagasitulek B ^ Rotl(B, 13) ^ Rotl(B, 23);
      tagasipöördumine B^(B<<13|B>>>19)^(B<<23|B>>>9);
}

void SMS4Crypt(bait[] Sisend, bait[] Väljund, int[] rk) {
      int r, mid, x0, x1, x2, x3;
      int[] x = uus int[4];
      int[] tmp = uus int[4];
      for (int i = 0; I < 4; i++) {
         tmp[0] = Sisend[0 + 4 * i] & 0xff;
         tmp[1] = Sisend[1 + 4 * i] & 0xff;
         tmp[2] = Sisend[2 + 4 * i] & 0xff;
         tmp[3] = Sisend[3 + 4 * i] & 0xff;
         x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
         x=(Input[0+4*i]<<24| Input[1+4*i]<<16| Input[2+4*i]<<8| Sisend[3+4*i]);
      }
      kui (r = 0; r < 32; r += 4) {
         mid = x[1] ^ x[2] ^ x[3] ^ rk[r + 0];
         mid = ByteSub(mid);
         x[0] = x[0] ^ L1(keskmine); x4

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

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

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

      Tagurpidi
      for (int j = 0; j < 16; j += 4) {
         Väljund[j] = (bait) (x[3 - j / 4] >>> 24 & 0xFF);
         Väljund[j + 1] = (bait) (x[3 - j / 4] >>> 16 & 0xFF);
         Väljund[j + 2] = (bait) (x[3 - j / 4] >>> 8 & 0xFF);
         Väljund[j + 3] = (bait) (x[3 - j / 4] & 0xFF);
      }
}

private void SMS4KeyExt(byte[] Key, int[] rk, int CryptFlag) {
      int r, mid;
      int[] x = uus int[4];
      int[] tmp = uus int[4];
      for (int i = 0; I < 4; i++) {
         tmp[0] = Võti[0 + 4 * i] & 0xFF;
         tmp[1] = Võti[1 + 4 * i] & 0xff;
         tmp[2] = Võti[2 + 4 * i] & 0xff;
         tmp[3] = Võti[3 + 4 * i] & 0xff;
         x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
         x=Võti[0+4*i]<<24| Key[1+4*i]<<16| Key[2+4*i]<<8| Võti[3+4*i];
      }
      x[0] ^= 0xa3b1bac6;
      x[1] ^= 0x56aa3350;
      x[2] ^= 0x677d9197;
      x[3] ^= 0xb27022dc;
      kui (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(keskmine); rk0=K4

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

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

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

      Dekrüpteeri rattavõtme järjekord: rk31, rk30,...,rk0
      if (CryptFlag == DEKRÜPTEERI) {
         kui (r = 0; r < 16; r++) {
            mid = rk[r];
            rk[r] = rk[31 - r];
            rk[31 - r] = keskmine;
         }
      }
}

public int sms4(bait[] sisse, int inLen, bait[] võti, bait[] välja, int CryptFlag) {
      int punkt = 0;
      int[] round_key = uus int[ROUND];
      int[] round_key={0};
      SMS4KeyExt(võti, round_key, CryptFlag);
      byte[] input = uus bait[16];
      bait[] väljund = uus bait[16];

      while (inLen >= BLOCK) {
         input = Arrays.copyOfRange(in, point, point + 16);
         output=Arrays.copyOfRange(väljas, punkt, punkt+16);
         SMS4Crypt (sisend, väljund, round_key);
         System.arraycopy (väljund, 0, väljund, punkt, BLOCK);
         inLen -= PLOKK;
         punkt += PLOKK;
      }

      tagasitulek 0;
}
}

Pakendatud väline liides:

Selle põhiklassi põhjal on peamised liidesed järgmised:

privaatne staatiline bait[] encode16(bait[] tavaline, bait[] võti);
privaatne staatiline bait[] decode16(bait[] šiffer, bait[] võti);
privaatne staatiline bait[] encode32(bait[] tavaline, bait[] võti);
privaatne staatiline bait[] decode32(bait[] šiffer, bait[] võti);
avalik staatiline bait[] encodeSMS4(bait[] tavaline, bait[] võti);
avalik staatiline bait[] dekodeerimine SMS4(bait[] šiffer, bait[] võti);
avalik staatiline string dekodeerimineSMS4toString(bait[] šiffer, bait[] võti);

encode16(bait[], bait[]) on liides 16-bitiste selgetekstiliste ja 16-bitiste võtmete krüpteerimiseks;
privaatne staatiline bait[] decode16(bait[] šiffer, bait[] võti: on liides 16-bitise šifriteksti ja 16-bitise võtme dekrüpteerimiseks;
privaatne staatiline bait[] encode32(bait[] tavaline, bait[] võti): See on liides, mis krüpteerib 32-bitised lihtteksti ja 16-bitised võtmed.
privaatne staatiline bait[] decode32(bait[] šifter, bait[] võti: See on liides 32-bitise šifriteksti ja 16-bitiste võtmete dekrüpteerimiseks.
avalik staatiline bait[] encodeSMS4(bait[] tavaline, bait[] võti: See on liides, mis krüpteerib lihtteksti ja 16-bitised võtmed piiramatu arvu baitidega.
avalik staatiline bait[] dekodeerimineSMS4(bait[] šiffer, bait[] võti: See on liides šifriteksti ja 16-bitiste võtmete dekrüpteerimiseks, millel on piiramatu arv baite.
avalik staatiline string dekodeerimineSMS4toString(bait[] šiffer, bait[] võti: See on liides piiramatu baitide šifriteksti ja 16-bitiste võtmete dekrüpteerimiseks.
Liidese meetodi kood:

public static byte[] encodeSMS4(String plaintext, byte[] key) {
      if (plaintext == null || plaintext.equals()) {
         return null;
      }
      for (int i = plaintext.getBytes().length % 16; I < 16; i++) {
         selgetekst += '';
      }

      return SMS4.encodeSMS4(plaintext.getBytes(), võti);
}

/**
   * SMS4 krüpteerimine piiramatu selgesõnalise pikkusega
   *
   * @param selge tekst
   * @param võti
   * @return
   */
avalik staatiline bait[] encodeSMS4(bait[] selge tekst, bait[] võti) {
      byte[] ciphertext = uus bait[plaintext.length];

      int k = 0;
      int plainLen = selgetekst.pikkus;
      samal ajal (k + 16 <= plainLen) {
         bait[] cellPlain = uus bait[16];
         for (int i = 0; I < 16; i++) {
            cellPlain= selgetekst[k + i];
         }
         byte[] cellCipher = encode16(cellPlain, key);
         for (int i = 0; i < cellCipher.length; i++) {
            šifrtekst[k + i] = cellCipher;
         }

         k += 16;
      }

      tagastada šifriteksti;
}

/**
   * SMS4 dekrüpteerimine ilma piiranguteta selge teksti pikkusele
   *
   * @param šifritekst
   * @param võti
   * @return
   */
avalik staatiline bait[] dekodeerimine SMS4(bait[] šifritekst, bait[] võti) {
      bait[] plaintext = uus bait[ciphertext.length];

      int k = 0;
      int cipherLen = šifritekst.pikkus;
      samal ajal (k + 16 <= cipherLen) {
         byte[] cellCipher = uus bait[16];
         for (int i = 0; I < 16; i++) {
            cellCipher= šifritekst[k + i];
         }
         byte[] cellPlain = decode16(cellCipher, key);
         for (int i = 0; i < cellPlain.length; i++) {
            plaintext[k + i] = cellPlain;
         }

         k += 16;
      }

      tagasta selge tekst;
}

/**
   * Dekrüpteerimine, et saada selgetekstilisi stringe
   * @param šifritekst
   * @param võti
   * @return
   */
public static String decodeSMS4toString(byte[] ciphertext, byte[] key) {
      bait[] plaintext = uus bait[ciphertext.length];
      selgetekst = dekodeerimine SMS4 (šifritekst, võti);
      return new string (selge tekst);
}

/**
   * Ainult 16-bitine selgetekst on krüpteeritud
   *
   * @param selge tekst
   * @param võti
   * @return
   */
privaatne staatiline bait[] encode16(bait[] selge tekst, bait[] võti) {
      bait[] šifer = uus bait[16];
      SMS4 sm4 = uus SMS4();
      sm4.sms4 (selgetekst, 16, võti, šiffer, KRÜPTEERIMINE);

      tagasi-šiffer;
}

/**
   * Dešifreeritakse ainult 16-bitine šifritekst
   *
   * @param selge tekst
   * @param võti
   * @return
   */
privaatne staatiline bait[] decode16(bait[] šifritekst, bait[] võti) {
      bait[] plain = uus bait[16];
      SMS4 sm4 = uus SMS4();
      sm4.sms4(šifritekst, 16, võti, lihtne, DEKRÜPTEERIMINE);

      tagasipöördumine lihtne;
}
Ma ei hakka siin tutvustama ainult 32-bitist selgeteksti krüpteerimist, mis on väga sarnane ainult 16-bitise selgeteksti meetodile.

Põhiline algoritm krüpteerimiseks ja dekrüpteerimiseks ilma selgeteksti pikkust piiramata põhineb sellel alusel, kus krüpteeritakse ja dekrüpteeritakse vaid 16 bitti. Lihtteksti puhul, mis on suurem kui 16 bitti, kasutatakse siin paketkkrüpteerimist. Kui kohtad selgteksti nagu 30 bitti, mida ei saa jagada 16-ga, siis täida see kuni 16-ga jaguneb. Põhimõtteliselt saab jagada ainult väikseimat arvu 16-ga, muidugi, kui oled rahul, pole oluline, kas teed selle suuremaks, sest see on sulgemissümbol.

Paketkrüpteerimine tähendab, et iga 16-bitine selgetekst krüpteeritakse üks kord ja seejärel kokku pannakse krüpteeritud 16-bitine šifritekst uueks šifritekstiks. Dekrüpteerimise käigus jagatakse see samuti üheks 16-bitiseks osaks ning seejärel mitmed neist dekrüpteeritud selgetekstidest pannakse kokku uueks selgetekstiks.

Kasutusdemonstratsioon:

Võti
      bait[] võti = { 0x01, 0x23, 0x45, 0x67, (bait) 0x89, (bait) 0xab,
            (bait) 0xcd, (bait) 0xef, (bait) 0xfe, (bait) 0xdc,
            (bait) 0xba, (bait) 0x98, 0x76, 0x54, 0x32, 0x10 };

      String newString = Kodeerimine, tere!; Selge tekst

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

      System.out.println (krüpteerimise tulemus:);
      printBit(enOut);

      byte[] deOut = SMS4.decodeSMS4(enOut, key);
      System.out.println(
dekrüpteerimise tulemus (tagasta bait[]) :);
      printBit(deOut);

      String deOutStr = SMS4.decodeSMS4toString(enOut, key);
      System.out.println(
Dekrüpteeri tulemus (return String):
+ deOutStr);

Xiaoweier · Postitatud 08.12.2015 22:25:41

Xiao Zhazha Postitatud 2015-12-8 22:19
SMS4 sissejuhatus:

See algoritm on grupeerimisalgoritm. Algoritmil on paketi pikkus 128 bitti ja võtme pikkus 128 bitti, mis on 16 baiti. ...

Kas sa kopeerid nägu sees? Olen seda algoritmi arvutis mitu korda käivitanud, kuid ma ei ole endiselt kursis C#-ga Java silumises, ma ei pruugi tema iga sammu detaili teada ega ole veel tema töö põhimõtet selgeks saanud. Java, kas tead, kuidas iga muutujat siluda?

Väike sodi · Postitatud 08.12.2015 22:40:48

See peaks olema katkestuspunkti määramiseks, myeclipse'i katkestuspunkti F5 ja F6 klahvid on üheastmelised silumised, F5 on step into, st sisesta reakood käivitamiseks, F6 on samm üle, st käivita reakood, hüpe järgmisele reale

Xiaoweier · Postitatud 08.12.2015 23:07:37

Avaldatud 2015-12-8 22:40
See peaks olema katkestuspunkti määramiseks, myeclipse breakpoint F5 klahv ja F6 klahv on mõlemad üheastmelised silumised, F5 on step in, st sisesta selle rea kood, et käivitada ...

Ma tean kindlasti, aga ma ei tea tema konkreetset protsessi ega tea, millal ja kus ma spetsifikatsiooni millisesse sammu jõuan. Oleks tore, kui sa mõistaksid

[Algoritm] SMS4 algoritm, mis on sümmeetriline plokkkrüptograafia algoritm

Vaadatud sektsioonid