SMS4 bevezetés:
Ez az algoritmus csoportosító algoritmus. Az algoritmus csomaghossza 128 bit, kulcshossza pedig 128 bit, ami 16 bájt. Mind a titkosítási algoritmus, mind a kulcsbővítési algoritmus 32 körös, nemlineáris iterációs struktúrát alkalmaz. A fejtős algoritmus szerkezete megegyezik a titkosítási algoritmussal, kivéve, hogy a kör kulcs használati sorrendje megfordul, és a fejtőkerék kulcsa a titkosítási kerék kulcsának fordított sorrendje. Az SMS4 összes alap osztályában látni fogja, hogy a titkosítás és a dekódolás alapfüggvényei ugyanazok, de egy int-típusú zászlóbit szükséges annak meghatározásához, hogy titkosított-e vagy lefejtette.
SMS4 titkosítási algoritmus alapjai:
közszolgálati osztály SMS4 {
privát statikus végső int TITKOSÍTÁS = 1;
privát statikus végső int DECRYPT = 0;
nyilvános statikus végső int ROUND = 32;
magán statikus végső int BLOCK = 16;
private byte[] Sbox = { (byte) 0xd6, (byte) 0x90, (byte) 0xe9, (byte) 0xfe,
(bájt) 0xcc, (bájt) 0xe1, 0x3d, (bájt) 0xb7, 0x16, (bájt) 0xb6,
0x14, (bájt) 0xc2, 0x28, (bájt) 0xfb, 0x2c, 0x05, 0x2b, 0x67,
(bájt) 0x9a, 0x76, 0x2a, (bájt) 0xbe, 0x04, (bájt) 0xc3,
(bájt) 0xaa, 0x44, 0x13, 0x26, 0x49, (bájt) 0x86, 0x06,
(bájt) 0x99, (bájt) 0x9c, 0x42, 0x50, (bájt) 0xf4, (bájt) 0x91,
(bájt) 0xef, (bájt) 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43,
(bájt) 0xed, (bájt) 0xcf, (bájt) 0xac, 0x62, (bájt) 0xe4,
(bájt) 0xb3, 0x1c, (bájt) 0xa9, (bájt) 0xc9, 0x08, (bájt) 0xe8,
(bájt) 0x95, (bájt) 0x80, (bájt) 0xdf, (bájt) 0x94, (bájt) 0xfa,
0x75, (bájt) 0x8f, 0x3f, (bájt) 0xa6, 0x47, 0x07, (bájt) 0xa7,
(bájt) 0xfc, (bájt) 0xf3, 0x73, 0x17, (bájt) 0xba, (baltáj) 0x83,
0x59, 0x3c, 0x19, (bájt) 0xe6, (bájt) 0x85, 0x4f, (bájt) 0xa8,
0x68, 0x6b, (bájt) 0x81, (bájt) 0xb2, 0x71, 0x64, (bájt) 0xda,
(bájt) 0x8b, (bájt) 0xf8, (bájt) 0xeb, 0x0f, 0x4b, 0x70, 0x56,
(bájt) 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, (bájt) 0xd1,
(bájt) 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, (bájt) 0x87,
(bájt) 0xd4, 0x00, 0x46, 0x57, (bájt) 0x9f, (bájt) 0xd3, 0x27,
0x52, 0x4c, 0x36, 0x02, (bájt) 0xe7, (bájt) 0xa0, (bájt) 0xc4,
(bájt) 0xc8, (bájt) 0x9e, (bájt) 0xea, (bájt) 0xbf, (bájt) 0x8a,
(bájt) 0xd2, 0x40, (bájt) 0xc7, 0x38, (bájt) 0xb5, (bájt) 0xa3,
(bájt) 0xf7, (bájt) 0xf2, (bájt) 0xce, (bájt) 0xf9, 0x61, 0x15,
(bájt) 0xa1, (bájt) 0xe0, (bájt) 0xae, 0x5d, (bájt) 0xa4,
(bájt) 0x9b, 0x34, 0x1a, 0x55, (bájt) 0xad, (bájt) 0x93, 0x32,
0x30, (bájt) 0xf5, (bájt) 0x8c, (bájt) 0xb1, (bájt) 0xe3, 0x1d,
(bájt) 0xf6, (bájt) 0xe2, 0x2e, (bájt) 0x82, 0x66, (bájt) 0xca,
0x60, (bájt) 0xc0, 0x29, 0x23, (bájt) 0xab, 0x0d, 0x53, 0x4e, 0x6f,
(bájt) 0xd5, (bájt) 0xdb, 0x37, 0x45, (bájt) 0xde, (bájt) 0xfd,
(bájt) 0x8e, 0x2f, 0x03, (bájt) 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b,
0x51, (bájt) 0x8d, 0x1b, (bájt) 0xaf, (bájt) 0x92, (bájt) 0xbb,
(bájt) 0xdd, (bájt) 0xbc, 0x7f, 0x11, (bájt) 0xd9, 0x5c, 0x41,
0x1f, 0x10, 0x5a, (bájt) 0xd8, 0x0a, (bájt) 0xc1, 0x31,
(bájt) 0x88, (bájt) 0xa5, (bájt) 0xcd, 0x7b, (bájt) 0xbd, 0x2d,
0x74, (bájt) 0xd0, 0x12, (bájt) 0xb8, (bájt) 0xe5, (bájt) 0xb4,
(bájt) 0xb0, (bájt) 0x89, 0x69, (bájt) 0x97, 0x4a, 0x0c,
(bájt) 0x96, 0x77, 0x7e, 0x65, (bájt) 0xb9, (bájt) 0xf1, 0x09,
(bájt) 0xc5, 0x6e, (bájt) 0xc6, (bájt) 0x84, 0x18, (bájt) 0xf0,
0x7d, (bájt) 0xec, 0x3a, (bájt) 0xdc, 0x4d, 0x20, 0x79,
(bájt) 0xee, 0x5f, 0x3e, (bájt) 0xd7, (bájt) 0xcb, 0x39, 0x48 };
private 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) {
vissza B ^ Rotl(B, 13) ^ Rotl(B, 23);
visszatérés B^(B<<13|B>>>19)^(B<<23|B>>>9);
}
void SMS4Crypt(byte[] Input, byte[] Output, int[] rk) {
Int R, Mid, x0, x1, x2, x3;
int[] x = új int[4];
int[] tmp = új int[4];
for (int i = 0; I < 4; i++) {
tmp[0] = Bemenet[0 + 4 * i] & 0xff;
tmp[1] = Bemenet[1 + 4 * i] & 0xff;
tmp[2] = Bemenet[2 + 4 * i] & 0xff;
tmp[3] = Bemenet[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| input[3+4*i]);
}
for (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
}
Hátul
for (int j = 0; j < 16; j += 4) {
Output[j] = (bájt) (x[3 - j / 4] >>> 24 & 0xFF);
Output[j + 1] = (bájt) (x[3 - j / 4] >>> 16 & 0xFF);
Output[j + 2] = (bájt) (x[3 - j / 4] >>> 8 & 0xFF);
Output[j + 3] = (bájt) (x[3 - j / 4] & 0xFF);
}
}
private void SMS4KeyExt(byte[] Key, int[] rk, int CryptFlag) {
Int R, közép;
int[] x = új int[4];
int[] tmp = új int[4];
for (int i = 0; I < 4; i++) {
tmp[0] = Kulcs[0 + 4 * i] & 0xFF;
tmp[1] = Kulcs[1 + 4 * i] & 0xff;
tmp[2] = Kulcs[2 + 4 * i] & 0xff;
tmp[3] = Kulcs[3 + 4 * i] & 0xff;
x= tmp[0] << 24 | TMP[1] << 16 | TMP[2] << 8 | TMP[3];
x=Key[0+4*i]<<24| Key[1+4*i]<<16| Key[2+4*i]<<8| Kulcs[3+4*i];
}
x[0] ^= 0xa3b1bac6;
x[1] ^= 0x56aa3350;
x[2] ^= 0x677d9197;
x[3] ^= 0xb27022dc;
for (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(közép) szinten; 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(közép) rk3=K7
}
Fejtse ki a kerékkulcs sorrendjét: rk31, rk30,...,rk0
if (CryptFlag == DECRYPT) {
for (r = 0; r < 16; r++) {
mid = rk[r];
rk[r] = rk[31 - r];
rk[31 - r] = közép;
}
}
}
public int sms4(byte[] in, int inLen, byte[] key, byte[] out, int CryptFlag) {
int pont = 0;
int[] round_key = új int[ROUND];
int[] round_key={0};
SMS4KeyExt(kulcs, round_key, CryptFlag);
byte[] input = új bájt[16];
byte[] output = új bájt[16];
míg (inLen >= BLOCK) {
input = Arrays.copyOfRange(in, point, point + 16);
output=Arrays.copyOfRange(out, point, point+16);
SMS4Crypt (bemenet, kimenet, round_key);
System.arraycopy (kimenet, 0, out, point, BLOCK);
inLen -= BLOCK;
pont += BLOKK;
}
return 0;
}
}
Csomagolt külső felület:
Ezen alaposztály alapján a fő interfészek a következők:
privát statikus bájt[] encode16(bájt[] egyszerű, bájt[] kulcs);
privát statikus bájt[] decode16(bájt[] titkosító, bájt[] kulcs;
privát statikus bájt[] encode32(bájt[] egyszerű, bájt[] kulcs;
privát statikus bájt[] decode32(bájt[] titkosító, bájt[] kulcs);
public static byte[] encodeSMS4(byte[] plain, byte[] key);
nyilvános statikus bájt[] dekódol: SMS4(bájt[] titkosító, bájt[] kulcs);
nyilvános statikus String dekódol: SMS4toString(byte[] titkosító, byte[] kulcs);
az encode16(byte[], byte[]) egy interfész 16 bites tiszta szöveg és 16 bites kulcsok titkosításához;
privát statikus bájt[] decode16(bájt[] titkosító, bájt[] kulcs): egy interfész a 16 bites titkosított szöveg és 16 bites kulcs visszafejtésére;
privát statikus bájt[] encode32(bájt[] egyszerű, bájt[] kulcs): Ez egy olyan interfés, amely 32 bites tiszta szöveget és 16 bites kulcsokat titkosít.
Privát statikus bájt[] decode32(bájt[] titkosító, bájt[] kulcs): Ez egy interfész a 32 bites titkosított szöveg és 16 bites kulcsok visszafejtésére.
nyilvános statikus bájt[] encodeSMS4(byte[] sima, bájt[] kulcs): Ez egy olyan interfész, amely titkosítja a tiszta szöveget és 16 bites kulcsokat korlátlan számú bájttal.
nyilvános statikus bájt[] dekódolvaSMS4(bájt[] titkosító, bájt[] kulcs): Ez egy interfész a titkosított szöveg és 16 bites kulcsok titkosításához, korlátlan számú bájttal történő visszafejtéshez.
nyilvános statikus String dekódolásSMS4toString(byte[] titkosító, bájt[] kulcs): Ez egy interfész korlátlan bájtok titkosított szöveg és 16 bites kulcsok visszafejtésére.
Interfész módszerkód:
public static byte[] encodeSMS4(String plaintext, byte[] key) {
if (plaintext == null || plaintext.equals()) {
return null;
}
for (int i = plaintext.getBytes().length % 16; 16 <; i++) {
tiszta szöveg += '';
}
return SMS4.encodeSMS4(plaintext.getBytes(), kulcs);
}
/**
* SMS4 titkosítás korlátlan tiszta szöveg hosszával
*
* @param tiszta szöveg
* @param kulcs
* @return
*/
public static byte[] encodeSMS4(byte[] plaintext, byte[] key) {
byte[] ciphertext = új bájt[plaintext.length];
int k = 0;
int plainLen = tiszta szöveg.hosszúság;
míg (k + 16 <= plainLen) {
byte[] cellPlain = új bájt[16];
for (int i = 0; 16 <; i++) {
cellPlain= tiszta szöveg[k + i];
}
byte[] cellCipher = encode16(cellPlain, key);
for (int i = 0; i < cellCipher.length; i++) {
titkosított szöveg[k + i] = cellCipher;
}
k += 16;
}
vissza a titkosított szöveget;
}
/**
* SMS4 titkosítás korlát nélküli tiszta szöveg hosszával
*
* @param titkosított szöveg
* @param kulcs
* @return
*/
nyilvános statikus bájt[] dekódoló SMS4(bájt[] titkosított szöveg, bájt[] kulcs) {
byte[] plaintext = új bájt[ciphertext.length];
int k = 0;
int cipherLen = titkosított szöveg.hosszúság;
míg (k + 16 <= cipherLen) {
byte[] cellCipher = új bájt[16];
for (int i = 0; 16 <; i++) {
cellCipher= titkosított szöveg[k + i];
}
byte[] cellPlain = decode16(cellCipher, kulcs);
for (int i = 0; i < cellPlain.length; i++) {
plaintext[k + i] = cellPlain;
}
k += 16;
}
a tiszta szöveg visszaadása;
}
/**
* Titkosítás a tiszta szöveges stringek megszerzéséhez
* @param titkosított szöveg
* @param kulcs
* @return
*/
public static String decodeSMS4toString(byte[] ciphertext, byte[] key) {
byte[] plaintext = új bájt[ciphertext.length];
plaintext = dekódolt SMS4 (titkosított szöveg, kulcs);
return new String (tiszta szöveg);
}
/**
* Csak 16 bites tiszta szöveg van titkosítva.
*
* @param tiszta szöveg
* @param kulcs
* @return
*/
privát statikus bájt[] encode16(bájt[] szöveg, bájt[] kulcs) {
byte[] cipher = új bájt[16];
SMS4 sm4 = új SMS4();
sm4.sms4 (tiszta szöveg, 16, kulcs, titkosítás, TITKOSÍTÁS);
visszaküldési titkosítás;
}
/**
* Csak 16 bites titkosított szöveg van dekódolva
*
* @param tiszta szöveg
* @param kulcs
* @return
*/
Private Static byte[] decode16(byte[] ciphertext, byte[] key) {
byte[] plain = új bájt[16];
SMS4 sm4 = új SMS4();
sm4.sms4(titkosított szöveg, 16, kulcs, egyszerű, DECRYPT);
visszatérés egyszerűen;
}
Nem vezetek be csak 32 bites tiszta szöveges titkosítást, ami nagyon hasonlít a 16 bites tiszta szöveg módszeréhez.
Az alapvető algoritmus a titkosításra és a titkosításra anélkül, hogy a tiszta szöveg hosszát korlátozná, ezen az alapon alapul, hogy csak 16 bitet titkosít és fejt. 16 bitnél nagyobb tiszta szöveg esetén itt csomagtitkosítást alkalmaznak. Ha olyan tiszta szöveggel találkozol, mint 30 bit, amit nem osztanak 16-tal, egy módja annak, hogy feltöltsd őket, amíg 16-tal osztható nem lesz. Elvileg csak a legkisebb számot lehet osztani 16-tal, persze, ha elégedett vagy, nem számít, ha nagyobbá teszed, mert ez a záró szimbólum.
A csomagtitkosítás azt jelenti, hogy minden 16 bites tiszta szöveget egyszer titkosítanak, majd a titkosított 16 bites titkosított szöveget egy új titkosított szöveggé egyesítik. A fejtés során egyetlen, 16 bites részre is feldarabolják, majd ezek közül több tiszta szöveget újraraknak új tiszta szöveggé.
Használati bemutató:
Kulcs
byte[] kulcs = { 0x01, 0x23, 0x45, 0x67, (byte) 0x89, (byte) 0xab,
(bájt) 0xcd, (bájt) 0xef, (bájt) 0xfe, (bájt) 0xdc,
(bájt) 0xba, (bájt) 0x98, 0x76, 0x54, 0x32, 0x10 };
String newString = Kódolás, helló!; Egyszerű szöveg
byte[] enOut = SMS4.encodeSMS4(newString, kulcs);
if (enOut == null) {
visszatérés;
}
System.out.println (titkosítási eredmény:);
printBit(enOut);
byte[] deOut = SMS4.decodeSMS4(enOut, key);
System.out.println(
A fejtés eredménye (visszaadja a bájt[]) :);
printBit(deOut);
String deOutStr = SMS4.decodeSMS4toString(enOut, key);
System.out.println(
A kimenetet dekódolni (return String):
+ deOutStr); |
Közzétéve 2015. 12. 08. 21:49:35
|
|
|
Közzétéve 2015. 12. 08. 22:19:05
|
Háziúr|
Közzétéve 2015. 12. 08. 22:25:41
|
