/*     */ package cn.com.esgcc.ai.matrix.sdk.util.encrypt.sm4;
/*     */ 
/*     */ import java.math.BigInteger;
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ public class Util
/*     */ {
/*     */   public static byte[] intToBytes(int num) {
/*  15 */     byte[] bytes = new byte[4];
/*  16 */     bytes[0] = (byte)(0xFF & num >> 0);
/*  17 */     bytes[1] = (byte)(0xFF & num >> 8);
/*  18 */     bytes[2] = (byte)(0xFF & num >> 16);
/*  19 */     bytes[3] = (byte)(0xFF & num >> 24);
/*  20 */     return bytes;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int byteToInt(byte[] bytes) {
/*  31 */     int num = 0;
/*     */     
/*  33 */     int temp = (0xFF & bytes[0]) << 0;
/*  34 */     num |= temp;
/*  35 */     temp = (0xFF & bytes[1]) << 8;
/*  36 */     num |= temp;
/*  37 */     temp = (0xFF & bytes[2]) << 16;
/*  38 */     num |= temp;
/*  39 */     temp = (0xFF & bytes[3]) << 24;
/*  40 */     num |= temp;
/*  41 */     return num;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] longToBytes(long num) {
/*  52 */     byte[] bytes = new byte[8];
/*  53 */     for (int i = 0; i < 8; i++)
/*     */     {
/*  55 */       bytes[i] = (byte)(int)(0xFFL & num >> i * 8);
/*     */     }
/*     */     
/*  58 */     return bytes;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] byteConvert32Bytes(BigInteger n) {
/*  69 */     byte[] tmpd = (byte[])null;
/*     */     
/*  71 */     if (n == null)
/*     */     {
/*  73 */       return null;
/*     */     }
/*  75 */     byte[] nByte = n.toByteArray();
/*  76 */     int len = nByte.length;
/*  77 */     if (len == 33) {
/*     */       
/*  79 */       tmpd = new byte[32];
/*  80 */       System.arraycopy(nByte, 1, tmpd, 0, 32);
/*     */     }
/*  82 */     else if (len == 32) {
/*     */       
/*  84 */       tmpd = nByte;
/*     */     }
/*     */     else {
/*     */       
/*  88 */       tmpd = new byte[32];
/*  89 */       for (int i = 0; i < 32 - len; i++)
/*     */       {
/*  91 */         tmpd[i] = 0;
/*     */       }
/*  93 */       System.arraycopy(nByte, 0, tmpd, 32 - len, len);
/*     */     } 
/*  95 */     return tmpd;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static BigInteger byteConvertInteger(byte[] b) {
/* 106 */     if (b[0] < 0) {
/*     */       
/* 108 */       byte[] temp = new byte[b.length + 1];
/* 109 */       temp[0] = 0;
/* 110 */       System.arraycopy(b, 0, temp, 1, b.length);
/* 111 */       return new BigInteger(temp);
/*     */     } 
/* 113 */     return new BigInteger(b);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String getHexString(byte[] bytes) {
/* 124 */     return getHexString(bytes, true);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String getHexString(byte[] bytes, boolean upperCase) {
/* 136 */     StringBuilder ret = new StringBuilder();
/* 137 */     for (int i = 0; i < bytes.length; i++)
/*     */     {
/* 139 */       ret.append(Integer.toString((bytes[i] & 0xFF) + 256, 16).substring(1));
/*     */     }
/* 141 */     return upperCase ? ret.toString().toUpperCase() : ret.toString();
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static void printHexString(byte[] bytes) {
/* 151 */     for (int i = 0; i < bytes.length; i++) {
/*     */       
/* 153 */       String hex = Integer.toHexString(bytes[i] & 0xFF);
/* 154 */       if (hex.length() == 1)
/*     */       {
/* 156 */         hex = '0' + hex;
/*     */       }
/* 158 */       System.out.print("0x" + hex.toUpperCase() + ",");
/*     */     } 
/* 160 */     System.out.println("");
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] hexStringToBytes(String hexString) {
/* 172 */     if (hexString == null || hexString.equals(""))
/*     */     {
/* 174 */       return null;
/*     */     }
/*     */     
/* 177 */     hexString = hexString.toUpperCase();
/* 178 */     int length = hexString.length() / 2;
/* 179 */     char[] hexChars = hexString.toCharArray();
/* 180 */     byte[] d = new byte[length];
/* 181 */     for (int i = 0; i < length; i++) {
/*     */       
/* 183 */       int pos = i * 2;
/* 184 */       d[i] = (byte)(charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
/*     */     } 
/* 186 */     return d;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte charToByte(char c) {
/* 198 */     return (byte)"0123456789ABCDEF".indexOf(c);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */   
/* 204 */   private static final char[] DIGITS_LOWER = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/* 210 */   private static final char[] DIGITS_UPPER = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static char[] encodeHex(byte[] data) {
/* 220 */     return encodeHex(data, true);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static char[] encodeHex(byte[] data, boolean toLowerCase) {
/* 231 */     return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   protected static char[] encodeHex(byte[] data, char[] toDigits) {
/* 242 */     int l = data.length;
/* 243 */     char[] out = new char[l << 1];
/*     */     
/* 245 */     for (int i = 0, j = 0; i < l; i++) {
/* 246 */       out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
/* 247 */       out[j++] = toDigits[0xF & data[i]];
/*     */     } 
/* 249 */     return out;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String encodeHexString(byte[] data) {
/* 259 */     return encodeHexString(data, true);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String encodeHexString(byte[] data, boolean toLowerCase) {
/* 270 */     return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   protected static String encodeHexString(byte[] data, char[] toDigits) {
/* 281 */     return new String(encodeHex(data, toDigits));
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] decodeHex(char[] data) {
/* 292 */     int len = data.length;
/*     */     
/* 294 */     if ((len & 0x1) != 0) {
/* 295 */       throw new RuntimeException("Odd number of characters.");
/*     */     }
/*     */     
/* 298 */     byte[] out = new byte[len >> 1];
/*     */ 
/*     */     
/* 301 */     for (int i = 0, j = 0; j < len; i++) {
/* 302 */       int f = toDigit(data[j], j) << 4;
/* 303 */       j++;
/* 304 */       f |= toDigit(data[j], j);
/* 305 */       j++;
/* 306 */       out[i] = (byte)(f & 0xFF);
/*     */     } 
/*     */     
/* 309 */     return out;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   protected static int toDigit(char ch, int index) {
/* 321 */     int digit = Character.digit(ch, 16);
/* 322 */     if (digit == -1) {
/* 323 */       throw new RuntimeException("Illegal hexadecimal character " + ch + " at index " + index);
/*     */     }
/*     */     
/* 326 */     return digit;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String StringToAsciiString(String content) {
/* 337 */     StringBuilder result = new StringBuilder();
/* 338 */     int max = content.length();
/* 339 */     for (int i = 0; i < max; i++) {
/* 340 */       char c = content.charAt(i);
/* 341 */       String b = Integer.toHexString(c);
/* 342 */       result.append(b);
/*     */     } 
/* 344 */     return result.toString();
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String hexStringToString(String hexString, int encodeType) {
/* 357 */     StringBuilder result = new StringBuilder();
/* 358 */     int max = hexString.length() / encodeType;
/* 359 */     for (int i = 0; i < max; i++) {
/* 360 */       char c = (char)hexStringToAlgorism(hexString
/* 361 */           .substring(i * encodeType, (i + 1) * encodeType));
/* 362 */       result.append(c);
/*     */     } 
/* 364 */     return result.toString();
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int hexStringToAlgorism(String hex) {
/* 375 */     hex = hex.toUpperCase();
/* 376 */     int max = hex.length();
/* 377 */     int result = 0;
/* 378 */     for (int i = max; i > 0; i--) {
/* 379 */       char c = hex.charAt(i - 1);
/* 380 */       int algorism = 0;
/* 381 */       if (c >= '0' && c <= '9') {
/* 382 */         algorism = c - 48;
/*     */       } else {
/* 384 */         algorism = c - 55;
/*     */       } 
/* 386 */       result = (int)(result + Math.pow(16.0D, (max - i)) * algorism);
/*     */     } 
/* 388 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String hexStringToBinary(String hex) {
/* 399 */     hex = hex.toUpperCase();
/* 400 */     String result = "";
/* 401 */     int max = hex.length();
/* 402 */     for (int i = 0; i < max; i++) {
/* 403 */       char c = hex.charAt(i);
/* 404 */       switch (c) {
/*     */         case '0':
/* 406 */           result = result + "0000";
/*     */           break;
/*     */         case '1':
/* 409 */           result = result + "0001";
/*     */           break;
/*     */         case '2':
/* 412 */           result = result + "0010";
/*     */           break;
/*     */         case '3':
/* 415 */           result = result + "0011";
/*     */           break;
/*     */         case '4':
/* 418 */           result = result + "0100";
/*     */           break;
/*     */         case '5':
/* 421 */           result = result + "0101";
/*     */           break;
/*     */         case '6':
/* 424 */           result = result + "0110";
/*     */           break;
/*     */         case '7':
/* 427 */           result = result + "0111";
/*     */           break;
/*     */         case '8':
/* 430 */           result = result + "1000";
/*     */           break;
/*     */         case '9':
/* 433 */           result = result + "1001";
/*     */           break;
/*     */         case 'A':
/* 436 */           result = result + "1010";
/*     */           break;
/*     */         case 'B':
/* 439 */           result = result + "1011";
/*     */           break;
/*     */         case 'C':
/* 442 */           result = result + "1100";
/*     */           break;
/*     */         case 'D':
/* 445 */           result = result + "1101";
/*     */           break;
/*     */         case 'E':
/* 448 */           result = result + "1110";
/*     */           break;
/*     */         case 'F':
/* 451 */           result = result + "1111";
/*     */           break;
/*     */       } 
/*     */     } 
/* 455 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String AsciiStringToString(String content) {
/* 466 */     StringBuilder result = new StringBuilder();
/* 467 */     int length = content.length() / 2;
/* 468 */     for (int i = 0; i < length; i++) {
/* 469 */       String c = content.substring(i * 2, i * 2 + 2);
/* 470 */       int a = hexStringToAlgorism(c);
/* 471 */       char b = (char)a;
/* 472 */       String d = String.valueOf(b);
/* 473 */       result.append(d);
/*     */     } 
/* 475 */     return result.toString();
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String algorismToHexString(int algorism, int maxLength) {
/* 488 */     String result = "";
/* 489 */     result = Integer.toHexString(algorism);
/*     */     
/* 491 */     if (result.length() % 2 == 1) {
/* 492 */       result = "0" + result;
/*     */     }
/* 494 */     return patchHexString(result.toUpperCase(), maxLength);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String byteToString(byte[] bytearray) {
/* 505 */     StringBuilder result = new StringBuilder();
/*     */ 
/*     */     
/* 508 */     int length = bytearray.length;
/* 509 */     for (int i = 0; i < length; i++) {
/* 510 */       char temp = (char)bytearray[i];
/* 511 */       result.append(temp);
/*     */     } 
/* 513 */     return result.toString();
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int binaryToAlgorism(String binary) {
/* 524 */     int max = binary.length();
/* 525 */     int result = 0;
/* 526 */     for (int i = max; i > 0; i--) {
/* 527 */       char c = binary.charAt(i - 1);
/* 528 */       int algorism = c - 48;
/* 529 */       result = (int)(result + Math.pow(2.0D, (max - i)) * algorism);
/*     */     } 
/* 531 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String algorismToHEXString(int algorism) {
/* 542 */     String result = "";
/* 543 */     result = Integer.toHexString(algorism);
/*     */     
/* 545 */     if (result.length() % 2 == 1) {
/* 546 */       result = "0" + result;
/*     */     }
/*     */     
/* 549 */     result = result.toUpperCase();
/*     */     
/* 551 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String patchHexString(String str, int maxLength) {
/* 564 */     String temp = "";
/* 565 */     for (int i = 0; i < maxLength - str.length(); i++) {
/* 566 */       temp = "0" + temp;
/*     */     }
/* 568 */     str = (temp + str).substring(0, maxLength);
/* 569 */     return str;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int parseToInt(String s, int defaultInt, int radix) {
/* 584 */     int i = 0;
/*     */     try {
/* 586 */       i = Integer.parseInt(s, radix);
/* 587 */     } catch (NumberFormatException ex) {
/* 588 */       i = defaultInt;
/*     */     } 
/* 590 */     return i;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int parseToInt(String s, int defaultInt) {
/* 603 */     int i = 0;
/*     */     try {
/* 605 */       i = Integer.parseInt(s);
/* 606 */     } catch (NumberFormatException ex) {
/* 607 */       i = defaultInt;
/*     */     } 
/* 609 */     return i;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] hexToByte(String hex) throws IllegalArgumentException {
/* 619 */     if (hex.length() % 2 != 0) {
/* 620 */       throw new IllegalArgumentException();
/*     */     }
/* 622 */     char[] arr = hex.toCharArray();
/* 623 */     byte[] b = new byte[hex.length() / 2];
/* 624 */     for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
/* 625 */       String swap = "" + arr[i++] + arr[i];
/* 626 */       int byteint = Integer.parseInt(swap, 16) & 0xFF;
/* 627 */       b[j] = Integer.valueOf(byteint).byteValue();
/*     */     } 
/* 629 */     return b;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String byteToHex(byte[] b) {
/* 640 */     if (b == null) {
/* 641 */       throw new IllegalArgumentException("Argument b ( byte array ) is null! ");
/*     */     }
/*     */     
/* 644 */     StringBuilder hs = new StringBuilder();
/* 645 */     String stmp = "";
/* 646 */     for (int n = 0; n < b.length; n++) {
/* 647 */       stmp = Integer.toHexString(b[n] & 0xFF);
/* 648 */       if (stmp.length() == 1) {
/* 649 */         hs.append('0');
/* 650 */         hs.append(stmp);
/*     */       } else {
/* 652 */         hs.append(stmp);
/*     */       } 
/*     */     } 
/* 655 */     return hs.toString().toUpperCase();
/*     */   }
/*     */   
/*     */   public static byte[] subByte(byte[] input, int startIndex, int length) {
/* 659 */     byte[] bt = new byte[length];
/* 660 */     for (int i = 0; i < length; i++) {
/* 661 */       bt[i] = input[i + startIndex];
/*     */     }
/* 663 */     return bt;
/*     */   }
/*     */ }


/* Location:              C:\Users\ningj\Desktop\java-sdk-1.0.0-SNAPSHOT\!\cn\com\esgcc\ai\matrix\sd\\util\encrypt\sm4\Util.class
 * Java compiler version: 8 (52.0)
 * JD-Core Version:       1.1.3
 */