Java に移植する必要がある Windows (Visual Studio) 用に記述された C++ コードがあります。これは非常に簡単ではなく、現在、 の正弦関数の使用に行き詰まっています。Linux (比較のためにテスト済み) と Java から得られた結果は、Windows ソースからの結果とは異なります。どちらの結果も間違っていますが、これは問題ではありません。結果がまったく同じであることが重要です。
ソース全体を一番下に掲載します。たとえば、5174852443848405000.0 のサインを計算する必要があります。これが非常に大きく、おそらく異常な数であることはわかっていますが、これを変更することはできません。Linux と Java は 0.153662 を返し、Windows は約 0.16xx を返します。関数「random_value_genrator()」は約 500,000 回使用されるため、結果の違いは後で発生する可能性があります。
initial_value_generator は、後で random_value_generator 関数によって使用される値を計算します。値は、FILETIME オブジェクトと 3 つの定数から生成されます。バッファ オーバーフローが発生していますが、処理されていません。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;
この関数は、プログラムの起動時に 1 回使用されます。大きな 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 コードを投稿します (コメントはすべて英語です)。私は多くのことをテストしていたので、ランダム関数は少しおかしく見えます。大変申し訳ございません。しかし、重要な点は、Microsoft C++ コンパイラを使用した Math.h の sin 関数とは結果が異なる Math.sin(double x) 関数の使用です。
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;
}