mycrypt.java

天乙代码src_531.rar 天乙代码src_531.rar 天乙代码src_531.rar 天乙代码src_531.rar

      buf[i + 1] = (char) ( (value >> 8) & 0xff);
      buf[i + 2] = (char) ( (value >> 16) & 0xff);
      buf[i + 3] = (char) ( (value >> 24) & 0xff);
      i += 4;
    }

  }

  private void setup_salt(char s[]) {
    int saltbits, value;
    int i, j;

    if (data.initialized == 0) {
      init_des();
    }
    if (s[0] == data.current_salt[0] && s[1] == data.current_salt[1]) {
      return;
    }

    data.current_salt[0] = s[0];
    data.current_salt[1] = s[1];

    saltbits = 0;
    for (i = 0; i < 2; i++) {
      int c = (int) ( (s[i]) >= 'a' ? (s[i] - 59) : (s[i]) >= 'A' ?
                     ( (s[i]) - 53) : (s[i]) - '.');
      for (j = 0; j < 6; j++) {
        if ( ( (c >> j) & 0x1) != 0) {
          saltbits |= BITMASK[6 * i + j];
        }
      }
    }

    shuffle_sb(data.sb[0], data.current_saltbits ^ saltbits);
    shuffle_sb(data.sb[1], data.current_saltbits ^ saltbits);
    shuffle_sb(data.sb[2], data.current_saltbits ^ saltbits);
    shuffle_sb(data.sb[3], data.current_saltbits ^ saltbits);

    data.current_saltbits = saltbits;
  }

  void mk_keytab(char key1[]) {
    int v1, v2;
    int i, j1 = 0, j2 = 0, j3 = 0;
    int v;
    int k2[] = data.keysched;
    int k1[][][];
    int k3[][];
    int i1, i2, i3, total;

    v1 = v2 = 0;
    k1 = do_pc1;
    for (i = 8; i-- > 0; ) {
      total = j1 + (key1[j2] & 0x7f);
      i1 = total / (2 * 128);
      i2 = (total % (2 * 128)) / 128;
      i3 = total - i1 * 2 * 128 - i2 * 128;
      v1 |= k1[i1][i2][i3];

      j1 += 128;

      total = j1 + (key1[j2++] & 0x7f);
      i1 = total / (2 * 128);
      i2 = (total % (2 * 128)) / 128;
      i3 = total - i1 * 2 * 128 - i2 * 128;
      v2 |= k1[i1][i2][i3];

      j1 += 128;
    }

    for (i = 0; i < 16; i++) {
      k3 = do_pc2;
      j1 = 0;

      v1 = (v1 << rots[i]) | (v1 >>> (28 - rots[i]));

      total = j1 + ( (v1 >> 21) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v = k3[i1][i2];
      j1 += 128;
      total = j1 + ( (v1 >> 14) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];
      j1 += 128;
      total = j1 + ( (v1 >> 7) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];
      j1 += 128;
      total = j1 + ( (v1) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];
      j1 += 128;

      k2[j3++] = (v | 0x00008000);
      v = 0;

      v2 = (v2 << rots[i]) | (v2 >>> (28 - rots[i]));

      total = j1 + ( (v2 >> 21) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];
      j1 += 128;
      total = j1 + ( (v2 >> 14) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];
      j1 += 128;
      total = j1 + ( (v2 >> 7) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];
      j1 += 128;
      total = j1 + ( (v2) & 0x7f);
      i1 = total / 128;
      i2 = total % 128;
      v |= k3[i1][i2];

      k2[j3++] = v | 0x00008000;
    }

    data.direction = 0;
  }

  private void dofinalperm() {
    int v1, v2, x;
    int l1, l2, r1, r2;

    l1 = res[0];
    l2 = res[1];
    r1 = res[2];
    r2 = res[3];

    x = (l1 ^ l2) & data.current_saltbits;
    l1 ^= x;
    l2 ^= x;
    x = (r1 ^ r2) & data.current_saltbits;
    r1 ^= x;
    r2 ^= x;

    v1 = v2 = 0;
    l1 >>= 3;
    l2 >>= 3;
    r1 >>= 3;
    r2 >>= 3;

    v1 |= efp[15][ (int) (r2 & 0x3f)][0];
    v2 |= efp[15][ (int) (r2 & 0x3f)][1];
    v1 |= efp[14][ (int) ( (r2 >>= 6) & 0x3f)][0];
    v2 |= efp[14][ (int) (r2 & 0x3f)][1];
    v1 |= efp[13][ (int) ( (r2 >>= 10) & 0x3f)][0];
    v2 |= efp[13][ (int) (r2 & 0x3f)][1];
    v1 |= efp[12][ (int) ( (r2 >>= 6) & 0x3f)][0];
    v2 |= efp[12][ (int) (r2 & 0x3f)][1];

    v1 |= efp[11][ (int) (r1 & 0x3f)][0];
    v2 |= efp[11][ (int) (r1 & 0x3f)][1];
    v1 |= efp[10][ (int) ( (r1 >>= 6) & 0x3f)][0];
    v2 |= efp[10][ (int) (r1 & 0x3f)][1];
    v1 |= efp[9][ (int) ( (r1 >>= 10) & 0x3f)][0];
    v2 |= efp[9][ (int) (r1 & 0x3f)][1];
    v1 |= efp[8][ (int) ( (r1 >>= 6) & 0x3f)][0];
    v2 |= efp[8][ (int) (r1 & 0x3f)][1];

    v1 |= efp[7][ (int) (l2 & 0x3f)][0];
    v2 |= efp[7][ (int) (l2 & 0x3f)][1];
    v1 |= efp[6][ (int) ( (l2 >>= 6) & 0x3f)][0];
    v2 |= efp[6][ (int) (l2 & 0x3f)][1];
    v1 |= efp[5][ (int) ( (l2 >>= 10) & 0x3f)][0];
    v2 |= efp[5][ (int) (l2 & 0x3f)][1];
    v1 |= efp[4][ (int) ( (l2 >>= 6) & 0x3f)][0];
    v2 |= efp[4][ (int) (l2 & 0x3f)][1];

    v1 |= efp[3][ (int) (l1 & 0x3f)][0];
    v2 |= efp[3][ (int) (l1 & 0x3f)][1];
    v1 |= efp[2][ (int) ( (l1 >>= 6) & 0x3f)][0];
    v2 |= efp[2][ (int) (l1 & 0x3f)][1];
    v1 |= efp[1][ (int) ( (l1 >>= 10) & 0x3f)][0];
    v2 |= efp[1][ (int) (l1 & 0x3f)][1];
    v1 |= efp[0][ (int) ( (l1 >>= 6) & 0x3f)][0];
    v2 |= efp[0][ (int) (l1 & 0x3f)][1];

    res[0] = v1;
    res[1] = v2;
  }

  void output_conversion(long v1, long v2, char salt[]) {
    int i, s, shf, c;

    data.crypt_3_buf[0] = salt[0];
    data.crypt_3_buf[1] = (salt[1] != 0) ? salt[1] : salt[0];

    for (i = 0; i < 5; i++) {
      shf = (26 - 6 * i);
      c = (int) ( (v1 >> shf) & 0x3f);
      data.crypt_3_buf[i +
          2] = (char) ( (c) >= 38 ? ( (c) - 38 + 'a') : (c) >= 12 ?
                       ( (c) - 12 + 'A') : (c) + '.');
    }

    s = (int) ( (v2 & 0xf) << 2);
    v2 = (v2 >> 2) | ( (v1 & 0x3) << 30);

    for (i = 5; i < 10; i++) {
      shf = (56 - 6 * i);
      c = (int) ( (v2 >> shf) & 0x3f);
      data.crypt_3_buf[i +
          2] = (char) ( (c) >= 38 ? ( (c) - 38 + 'a') : (c) >= 12 ?
                       ( (c) - 12 + 'A') : (c) + '.');
    }

    data.crypt_3_buf[12] = (char) ( (s) >= 38 ? ( (s) - 38 + 'a') : (s) >= 12 ?
                                   ( (s) - 12 + 'A') : (s) + '.');
    //data.crypt_3_buf[13]=0;
  }

  private void doit(int itr) {
    int i, j = 0;
    int l1, l2, r1, r2;
    int s;
    int k[];
    int sb01 = 0; //data.sb[0];
    int sb23 = 2; //data.sb[2];
    int value;

    l1 = res[0];
    l2 = res[1];
    r1 = res[2];
    r2 = res[3];

    while (itr-- > 0) {
      k = data.keysched;
      j = 0;
      for (i = 8; i-- > 0; ) {
        s = k[j++] ^ r1;
        l1 ^= SBA(sb01, s & 0xffff);
        l2 ^= SBA(sb01, (s & 0xffff) + 4);
        l1 ^= SBA(sb01, s >>>= 16);
        l2 ^= SBA(sb01, (s) + 4);

        s = k[j++] ^ r2;
        l1 ^= SBA(sb23, s & 0xffff);
        l2 ^= SBA(sb23, (s & 0xffff) + 4);
        l1 ^= SBA(sb23, s >>>= 16);
        l2 ^= SBA(sb23, (s) + 4);

        s = k[j++] ^ l1;
        r1 ^= SBA(sb01, s & 0xffff);
        r2 ^= SBA(sb01, (s & 0xffff) + 4);
        r1 ^= SBA(sb01, s >>>= 16);
        r2 ^= SBA(sb01, (s) + 4);
        s = k[j++] ^ l2;
        r1 ^= SBA(sb23, s & 0xffff);
        r2 ^= SBA(sb23, (s & 0xffff) + 4);
        r1 ^= SBA(sb23, s >>>= 16);
        r2 ^= SBA(sb23, (s) + 4);
      }
      s = l1;
      l1 = r1;
      r1 = s;
      s = l2;
      l2 = r2;
      r2 = s;
    }
    res[0] = l1;
    res[1] = l2;
    res[2] = r1;
    res[3] = r2;
  }

  private int SBA(int m, long v) {
    int i;
    int o;
    m += v / 32768;
    o = ( (int) v) % 32768;

    i = data.sb[m][o];
    i += ( (data.sb[m][o + 1]) << 8);
    i += ( (data.sb[m][o + 2]) << 16);
    i += ( (data.sb[m][o + 3]) << 24);

    return i;
  }

  private String crypt_p(String key1, String salt) {
    char ktab[] = new char[30];
    int xx = 25;
    int i;
    char salt_c[] = new char[2];

    int len = salt.length();
    if (len <= 2) {
      salt.getChars(0, len, salt_c, 0);
    }
    else {
      salt.getChars(0, 2, salt_c, 0);

    }
    setup_salt(salt_c);

    /*
     * Setup key schedule
     */
    len = key1.length();
    if (len <= 8) {
      key1.getChars(0, len, ktab, 0);
    }
    else {
      key1.getChars(0, 8, ktab, 0);

      //copymem(key1,ktab,8);
    }
    mk_keytab(ktab);

    /*
     * Go for the 25 DES encryptions
     */
    //clearmem ( res, res.length);
    doit(xx);

    /*
     * Do final permutations
     */
    dofinalperm();

    /*
     * And convert back to 6 bit ASCII
     */
    //System.out.println("**"+res[0]+","+res[1]+"**");
    output_conversion(res[0], res[1], salt_c);

    return new String(data.crypt_3_buf);
  }

  public static String genPassword(String input) {
    char salt_c[] = new char[2];

    int i = (int) (Math.random() * 32767);
    salt_c[0] = (char) (i & 077);
    salt_c[1] = (char) ( (i >> 6) & 077);
    for (i = 0; i < 2; i++) {
      salt_c[i] += '.';
      if (salt_c[i] > '9') {
        salt_c[i] += 7;
      }
      if (salt_c[i] > 'Z') {
        salt_c[i] += 6;
      }
    }

    return MyCrypt.crypt(input, new String(salt_c));
  }

  public static String crypt(String input, String salt) {
    String result = "";

//        int len=input.length();
//        for(int i=0;i<len;i+=8){
    MyCrypt crypt = new MyCrypt();
    result = crypt.crypt_p(input, salt);

    return result;
  }

  public static boolean validatePassword(String password, String input) {
    String result = MyCrypt.crypt(input, password);

    if (result == null) {
      return false;
    }
    else {
      return result.equals(password);
    }
  }
}