0

我有一个为 Windows (Visual Studio) 编写的 C++ 代码，我需要将其移植到 Java 中。这不是很容易，目前我被困在 . Linux（经过测试可以进行比较）和 Java 给出的结果与 Windows 源的结果不同。两个结果都是错误的，但这并不重要。重要的是结果完全相同。

我将在底部发布整个源代码。例如我需要计算 5174852443848405000.0 的正弦值。我知道这是一个非常大而且可能不寻常的数字，但我无法改变这一点。Linux 和 Java 返回 0.153662，Windows 返回大约 0.16xx。函数“random_value_genrator()”被使用了大约 500,000 次，因此结果的差异可能会在稍后的某个时间出现。

initial_value_generator 将计算一个稍后由 random_value_generator 函数使用的值。该值由一个 FILETIME 对象和三个常量生成。缓冲区溢出发生但未处理。random_value_generator 每次使用时都会修改 DWORD64 prng_initial_value。

我能够成功构建 initial_value_generator 函数。

我想我无法完成这项任务，但感谢任何帮助。

一些全局变量：

DWORD64 prng_initial_value = 0;

DWORD64 CON1_RVG = 0x4F3D859E;
double CON2_RVG = 0.946270391;

DWORD64 CON1_PRNG = 0x2682D10B7;
DWORD64 CON2_PRNG = 0x19254D38000;
DWORD64 CON3_PRNG = 0x0F1E34A09;

该功能在程序启动时使用一次。将一个大的 DWORD64 写入 prng_initial_value，稍后由 random_value_generator() 使用。系统时间乘以常数 1（缓冲区溢出），除以常数 2，再加上常数 3。

void initial_value_generator ()
{
    SYSTEMTIME systime;
    FILETIME filetime;

    // Systemzeit zu GMT-Format umwandeln
    SystemTimeToFileTime(&systime,&filetime);

    prng_initial_value = (*(DWORD64*)&filetime) * CON1_PRNG / CON2_PRNG + CON3_PRNG;
}

此函数在每次使用时更改 DWORD64 prng_initial_value。

int random_value_generator () 
{
    double sin_value;
    double copy_of_prng_initial_value;
    DWORD64 prng_con1;
    double result;

    // Initialen Wert aus dem initial_random_generator in lokaler Variable speichern
    copy_of_prng_initial_value = prng_initial_value;

    // Sinus vom initialen Wert 
    sin_value = sin(copy_of_prng_initial_value);

    // Initialen Wert mulipikation mit einem konstanten Wert (0x4F3D859E)
    prng_con1 = prng_initial_value * CON1_RVG;

一些进一步的计算变得疯狂：

    result = prng_con1 + sin_value;
    result = result * copy_of_prng_initial_value;
    result = result + CON2_RVG;
    result = result * copy_of_prng_initial_value;

    // Das Ergebnis aus der Logarithmus Rechnung addieren
    result += log(copy_of_prng_initial_value);

    // Das Ergebnis aus den Berechnungen als Pointer in die
    // Speicheradresse von prng_initial_value als double Pointer speichern.
    *(double*)&prng_initial_value = result;

    // Rueckgabe des Berechneten Wert als Integer
    return prng_initial_value;
}

作为参考，我发布了我的 Java 代码（所有评论都是英文的）。随机函数看起来有点疯狂，因为我正在测试很多东西。我对此感到非常抱歉。但重要的一点是使用 Math.sin(double x) 函数，其结果与使用 Microsoft C++ 编译器的 Math.h 中的 sin 函数不同。

private final long initialValue;
private long randomValue;
final BigInteger uint64MaxValue = new BigInteger("18446744073709551616");   //2^64

public ConfickerC() {
    this.initialValue = this.generateInitialValue();
    this.randomValue = this.initialValue;
}

private long generateInitialValue() {
    //We need the actual date without the time from GMT +0 timezone
    Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
    cal.set(Calendar.HOUR_OF_DAY, 0);
    cal.set(Calendar.MINUTE, 0);
    cal.set(Calendar.SECOND, 0);
    cal.set(Calendar.MILLISECOND, 0);

    long systemtimeAsFiletime = cal.getTimeInMillis();

    /*
     * Goal is to get the above created date into Windows FileTime format.
     * The Windows FileTime format has got 100 nano seconds per tick.
     * So one increment of the long value results further 100 nano seconds.
     * Instead of Unix the FileTime format begins with 1st January 1601 - not 1970.
     * 11644473600 is the interval between 1601 and 1970 in seconds.
     * Java has got a resolution of 1 ms per tick unix have got 1 second per
     * tick. So first devide the time by 1000. Then add the interval. 
     * After this we multiply by 10 million to get a resolution of 100
     * nano seconds per tick.
     */
    systemtimeAsFiletime /= 1000;        //divide by 1000 to get seconds instead of milliseconds
    systemtimeAsFiletime += 11644473600L; //add x seconds to add the interval between 1601 and 1970
    systemtimeAsFiletime *= 10000000L;   //Windows FileTime has a resolution of 100 nano seconds per tick; so multiply by 10M

    /*
     * The virus is calulating for getting the initial value: time * con1 / con2 + con3
     * Originaly there occurs a buffer overflow which is not handled in the C++ code.
     * The funny thing is that Java does not have a DWORD64 (unsinged _int64). So because of this bit missing (and so the overflow is different) we need BigInteger. 
     * Because BigInteger has no 2^64 limitation we need the maximul value of DWORD64.
     * This is used to "simulate" the buffer overflow by calculating ((time * con1) % 2^64) / con2 + con3
     * modulo 2^64 will result a value which is equal to the C++ calculation
     */

    final BigInteger CONSTANT_1 = new BigInteger("10337718455");                //Original: 0x2682D10B7
    final BigInteger CONSTANT_2 = new BigInteger("1728000000000");              //Original: 0x19254D38000
    final BigInteger CONSTANT_3 = new BigInteger("4058204681");                 //Original: 0x0F1E34A09

    BigInteger bigIntSystemTime = BigInteger.valueOf(systemtimeAsFiletime);

    //Return as long value: ((time * con1) % 2^64) / con2 + con3
    return bigIntSystemTime.multiply(CONSTANT_1).divideAndRemainder(uint64MaxValue)[1].divide(CONSTANT_2).add(CONSTANT_3).longValue();
}

private int generateRandomValue() {
    final long CONSTANT_1 = 1329431966L;
    final double CONSTANT_2 = 0.946270391;
    double result = 0.0;
    double copyOfInit = this.randomValue;

    System.out.println(System.getProperty("line.separator") + "Copy of init: " + copyOfInit);
    System.out.printf("Copy of init: %f\n", copyOfInit);
    double sinInit = Math.sin(copyOfInit); System.out.println("Sinus: " + sinInit);  
    System.out.printf("Sinus: %f\n", sinInit);
    System.out.println("Sinus gerundet: " + Math.round(sinInit*1000000)/1000000.0d);
    BigInteger b =        BigInteger.valueOf(this.randomValue).multiply(BigInteger.valueOf(CONSTANT_1)).divideAndRemainder(uint64MaxValue)[1];

    System.out.println("Init * Konstante 1: " + b);
    BigDecimal bd = new BigDecimal(b.toString());
    //bd.add(BigDecimal.valueOf(sinInit));

    //result = t + sinInit; System.out.println("Multi + Sinus: " + result);
    result = bd.add(BigDecimal.valueOf(sinInit)).doubleValue(); System.out.println("Multi + Sinus: " + result);
    result *= (long) this.randomValue; System.out.println("Zwischenergebnis * init: " + result);
    result += CONSTANT_2; System.out.println("Konstante 2 addiert: " + result);
    System.out.printf("BigD: %s", BigDecimal.valueOf(result).multiply(BigDecimal.valueOf(randomValue)));
    result *= this.randomValue; System.out.printf("Erneut mit init multipliziert: %f", result);
    double l = Math.log((long)this.randomValue); System.out.println("Log von init: " + l);
    result += l; System.out.printf("+= mit Log: %f\n", result);

    this.randomValue = (long)result; System.out.printf("Ende: %d\n", this.randomValue);

    this.randomValue = Double.doubleToRawLongBits(result);

    return (int)this.randomValue;   
}
4

1 回答 1

2

三角函数是具有相当模糊规范的库函数。例如，以下是 C 标准对这个主题 (7.12.4.6) 所说的话：

sin函数

概要

#include <math.h>
double sin(double x);
float sinf(float x);
long double sinl(long double x);

描述

这些sin函数计算x（以弧度为单位）的正弦值。

退货

sin函数返回sinx

因此，它们将使用不同的算法和不同的精度，即，使用库版本您不会得到完全相同的结果。例如，不同的库可能会在准确性和计算速度之间做出不同的权衡。即使库实现完全相同，您也可能不会在不同系统上得到完全相同的结果，因为在整个计算过程中，值可能会在不同点进行四舍五入。要在不同平台之间获得相当接近的结果，您可能需要在这些平台上实现相同的算法。

请注意，这sin(x)显然提供了范围内的最佳结果[0, π/2]。传递一个巨大的数字sin(x)可能会产生一个相当糟糕的近似值，尽管我希望大多数实现会x在进行任何计算之前从映射到上面给出的范围开始。理想情况下，您应该从一开始就避免使用较大的值，π而是用倍数来表达它们。但是，即使x落在上述范围内，您也可能会从不同的实现中得到不同的结果。

于 2013-10-28T21:31:48.110 回答