Java 需要帮助反向工程一个算法吗

我被困在一段java代码的逆向工程中。我想知道是否有人能帮我

String var1 = "hello";
String var2 = "123456";

long var_l = 0L;
byte[] a1 = new byte[50];
byte[] a2 = new byte[50];

// i believe this checks if its between a-Z?
for (int j = 0; j < var1.length(); j++)
{
    a2[j] = (byte) var1.charAt(j);

    if ((a2[j] < 65) || (a2[j] > 122)
    {
        continue;
    } 

    var_l += 145 + a2[j];
}

String var1=“hello”；
字符串var2=“123456”；
长变量=0L；
字节[]a1=新字节[50]；
字节[]a2=新字节[50]；
//我相信这会检查它是否在a-Z之间？
对于（int j=0；j122）
{
继续；
} 
var_l+=145+a2[j]；
}

下一部分我真的不明白

var_l *= a1[0]; // a1 is a byte array of var2
var_l = 0xFFFF & var_l * (0xFF & var_l);

if (var_l < 100L)
{
    var_l = 2728L;
}

var_l*=a1[0]；//a1是var2的字节数组
var_l=0xFFFF&var_l*（0xFF&var_l）；
如果（变量小于100L）
{
var_l=2728L；
}

有人能帮我一下吗？我想在这里学习密码算法，但我在逻辑上有困难

以下是完整的代码：

param_licensekey&licensename&LiceType是全局变量。请阅读我下面的评论，了解我反向工程的原因。感谢所有的awnsers

public boolean check_license()
  {
    long l = 0L;
    byte[] arrayOfByte2 = new byte['ÿ'];
    byte[] arrayOfByte1 = new byte['ÿ'];
    int i;
    if (this.param_licensename.length() >= 2)
    {
      if (this.param_licensekey.length() >= 2)
      {
        for (int j = 0; j < this.param_licensekey.length(); j++)
          arrayOfByte1[j] = (byte)this.param_licensekey.charAt(j);
        for (j = 0; j < this.param_licensename.length(); j++)
        {
          arrayOfByte2[j] = (byte)this.param_licensename.charAt(j);
          if ((this.param_licensename.charAt(j) < 'A') || (this.param_licensename.charAt(j) > 'Z'))
            continue;
          arrayOfByte2[j] = (byte)(32 + arrayOfByte2[j]);
        }
        for (j = 0; j < this.param_licensename.length(); j++)
        {
          if ((arrayOfByte2[j] < 65) || (arrayOfByte2[j] > 122))
            continue;
          l += 145 + arrayOfByte2[j];
        }
        l *= arrayOfByte1[0];
        l = 0xFFFF & l * (0xFF & l);
        if (l < 100L)
          l = 2728L;
        String str = this.param_licensekey.charAt(0) + l;
        if (!this.param_licensekey.startsWith(str))
        {
          this.lictype = -1;
          i = 0;
        }
        else
        {
          this.lictype = (i[0] - 48);
          i = 1;
        }
      }
      else
      {
        i = 0;
      }
    }
    else
      i = 0;
    return i;
  }

公共布尔检查\u许可证（）
{
长l=0L；
字节[]arrayOfByte2=新字节['ÿ']；
byte[]arrayOfByte1=新字节['ÿ']；
int i；
if（this.param_licensename.length（）>=2）
{
if（this.param_licensekey.length（）>=2）
{
对于（int j=0；j'Z'））
继续；
arrayOfByte2[j]=（字节）（32+arrayOfByte2[j]）；
}
对于（j=0；j122））
继续；
l+=145+arrayOfByte2[j]；
}
l*=arrayOfByte1[0]；
l=0xFFFF&l*（0xFF&l）；
如果（l<100L）
l=2728L；
String str=this.param_licensekey.charAt（0）+l；
如果（！this.param_licensekey.startsWith（str））
{
this.lictype=-1；
i=0；
}
其他的
{
this.lictype=（i[0]-48）；
i=1；
}
}
其他的
{
i=0；
}
}
其他的
i=0；
返回i；
}

//var\u l=var\u l*a1[0]
var_l*=a1[0]；//a1是var2的字节数组
//var_l的低位16位乘以var_l的低位8位（括号）
//在这种情况下不需要）。
var_l=0xFFFF&var_l*（0xFF&var_l）；
//不言自明
如果（变量小于100L）{
var_l=2728L；
}

//var\u l=var\u l*a1[0]
var_l*=a1[0]；//a1是var2的字节数组
//var_l的低位16位乘以var_l的低位8位（括号）
//在这种情况下不需要）。
var_l=0xFFFF&var_l*（0xFF&var_l）；
//不言自明
如果（变量小于100L）{
var_l=2728L；
}

作为参考，这看起来像是一个试图用Java编写C'ish代码的人的工作。它也可能是反编译器的结果。在我看来，反编译器不能像这段代码那样任意使用数组。即使这些东西是内联的，也会有很大的延伸。这看起来像是一些非常愚蠢的哈希函数n对我来说。大家好，这是Java反编译器的工作。它在获取源代码方面做得很好。我仍在努力解决它。我将发布整个函数。请记住，我不是为了非法目的而使用它，而是为了学习材料。这是我老师的一个反编译jar，考试中可能会有关于它的问题。供参考nce，这看起来像是一个试图用Java编写C'ish代码的人的工作。它也可能是反编译器的结果。在我看来，反编译器不能像这段代码那样任意使用数组。即使这些东西是内联的，也会有相当大的延伸。这看起来像是一个非常愚蠢的哈希函数。嗨，伙计们，这是Java反编译器的工作。它在获取源代码方面做得很好。我仍在努力解决它。我将发布整个函数。请记住，我不是为了非法目的而使用它，而是为了学习材料。这是我老师提供的一个反编译jar，考试中可能会有关于它的问题。“不言自明”部分仍然有点有趣。2728L硬代码可能是某种位掩码。在二进制中是101010101000。这看起来确实是位上的排序模式。了解var_1是如何在其下游使用的是很有趣的。“自解释的”部分仍然有点有趣。2728L硬代码可能是某种位掩码。在二进制中是101010101000。这看起来确实是位上的排序模式。了解var_1在这之后是如何使用的将是很有趣的。

// var_l = var_l * a1[0]
var_l *= a1[0]; // a1 is a byte array of var2

// The low 16 bits of var_l are multipled by the low 8 bits of var_l (the parenthesis
// are not necessary in this case).
var_l = 0xFFFF & var_l * (0xFF & var_l);

// Self explanatory
if (var_l < 100L) {
 var_l = 2728L;
}