61

我只是使用 proguard 混淆了我的 Android 代码，然后对其进行了反编译。有许多字符串我真的很想隐藏以免被窥探。当我反编译我的代码时，每个人都可以看到字符串......并进行更改。其中一个字符串是我的许可服务器的 URL，它们实际上可以将 url 更改为指向假服务器（因为我将向公众发布服务器代码）。隐藏此类信息的最佳方法是什么？

另外，我注意到 R 类字符串都是随机数，但我在反编译代码中找不到 R 类。它在哪里？

我看到的敌人示例：new SimpleCursorAdapter(localActivity, 2130903058, localCursor, arrayOfString, arrayOfInt);

2130903058 是一个布局文件，但它引用的是什么？这个数字没有任何意义，除非它指向某种地址。

4

7 回答 7

34

假设您对模糊而不是安全感到满意，您可以使用许多机制，但像 proguard 这样的混淆器将无法为您提供帮助。

要实现这一点，您需要自己对字符串进行编码或加密，您使用的方法取决于您要防御的内容，如果您只是想隐藏明显的检查，那么编码可能就足够了（请参阅 android .util.Base64，http://developer.android.com/reference/android/util/Base64.html）。请注意，编码是不安全的，它所要做的就是删除对您网站的明显引用。

如果您试图防御更多的东西，那么您可以转向实际加密字符串，为此您将通过 javax.crypto.Cipher 使用像 AES 这样的对称密码，http: //www.androidsnippets.org/snippets/ 39/index.html提供了一个不错的使用示例。同样，这对黑客来说更烦人，然后更安全，因为您需要将密钥存储在 jar 中的某个位置，从而否定任何加密安全性。

为了更清楚地说明这一点，基本步骤是：

  1. 使用已知密钥手动创建加密字符串。
  2. 将您的代码转换为使用此字符串的解密版本，例如：

前：

public class Foo {
    private String mySecret = "http://example.com";

    ...
}

变成：

public class Foo {
    private String encrypted = "<manually created encrypted string>";
    private String key = "<key used for encryption";
    private String mySecret = MyDecryptUtil.decrypt(encrypted, key);

    ...
}

所有这一切的（好的）替代方案是考虑使用第三方drm解决方案，例如谷歌提供的许可服务器http://android-developers.blogspot.com/2010/07/licensing-service-for-android.html。这可能比你自己滚动的东西更安全，但受到与我上面描述的非常相似的限制。

于 2010-12-13T09:32:57.033 回答
26

大家好。

  1. 让secret成为你想要隐藏的文字

  2. 找到你的 debug/release.keystore 的 keyhash。让k1这把钥匙。

（使用工具 keytool+openssl: keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64 ）

  1. secret使用工具（android代码外部）进行加密k1

    encrypted = encode (secret, k1)

（例如：https ://jwt.io ，对于 java：https ://github.com/jwtk/jjwt ）。

  1. 在你的 android java 代码中写下encrypted. 当您需要encrypted（这是原始secret）的解码版本时，请编写

original = decode(encrypted, get_my_keyhash_programmatically() )

就这样。这是有效的，因为原始secret代码没有显示在 java 源代码上，也没有k1解码它。而且，如果黑客想要打印您解码的秘密，他必须更改代码并重新编译，用他自己的密钥库而不是您的密钥库签署他的 .apk，因此无法获得正确的原始 .apk secret。（“唯一”的一点是是否k1可以从您的原始 .apk 中找出）。

注意：get_my_keyhash_programmatically()：

try {
    PackageInfo info = getPackageManager().getPackageInfo(
            "el nombre de su paquete por ejemplo com.tarea.u8",
            PackageManager.GET_SIGNATURES);
    for (Signature signature : info.signatures) {
        MessageDigest md = MessageDigest.getInstance("SHA");
        md.update(signature.toByteArray());
        Log.d("KeyHash:", Base64.encodeToString(md.digest(), Base64.DEFAULT));
    }
} catch (PackageManager.NameNotFoundException e) {

} catch (NoSuchAlgorithmException e) {

}
于 2016-02-23T11:48:45.590 回答
9

我所做的是在我的全局实用程序类中创建一长串静态字符串。在长长的字符串列表中的某个地方，我将密码分成多个块。

使用我的代码很容易看出真正的密钥是什么——但是一旦混淆器开始工作，所有的静态变量都会有 A、B、C 等名称，而且再也不容易发现了。

于 2011-03-08T03:35:53.357 回答
2

我用的是ROT47。它不是很安全，但易于使用和实现，因为它是一个对称的编码器/解码器

于 2013-07-02T06:54:04.980 回答
1

你应该用谷歌搜索“Just another Perl hacker”。这些是打印出带有混淆代码的字符串的程序。网上还有很多其他语言的例子，然后是 Perl。

维基百科条目

于 2010-12-13T10:18:43.893 回答
0

这是我目前使用的，它具有支持 sprintf 函数的技巧，这些函数将纯文本溢出到编译的二进制文件中。您现在可以使用 w_sprintf_s 而不是 sprintf，就像这样

char test[256] = { 0 };
w_sprintf_s(test, 256, XorStr("test test :D %d %+d\n"), 1, 1337);

或者像这样使用它在屏幕上打印东西，例如

w_printf(XorStr("test I print this and can't see me inside .dll or .exe"));

适用于变量，如果您有自定义 printf() 您也可以使用它..

char szGuid[255] = { 0 };
//generate serial code removed.
char finalSerial[512] = { 0 };
XorCompileTime::w_sprintf(finalSerial, XorStr("serial information=%s"), szGuid);
myprintf(XorStr("Your Hardware ID: %s\n"), szGuid);


可能会像 arkan 那样添加对 wchar_t 宽字符串的支持。但我现在对它们没有用处，因为我没有在符号/unicode 中写任何东西。

这是一个文件，只需将下面的代码重命名为XorString.h文件并将其包含在您的项目中即可

#pragma once
#include <string>
#include <array>
#include <cstdarg>

#define BEGIN_NAMESPACE( x ) namespace x {
#define END_NAMESPACE }

BEGIN_NAMESPACE(XorCompileTime)

constexpr auto time = __TIME__;
constexpr auto seed = static_cast< int >(time[7]) + static_cast< int >(time[6]) * 10 + static_cast< int >(time[4]) * 60 + static_cast< int >(time[3]) * 600 + static_cast< int >(time[1]) * 3600 + static_cast< int >(time[0]) * 36000;

// 1988, Stephen Park and Keith Miller
// "Random Number Generators: Good Ones Are Hard To Find", considered as "minimal standard"
// Park-Miller 31 bit pseudo-random number generator, implemented with G. Carta's optimisation:
// with 32-bit math and without division

template < int N >
struct RandomGenerator
{
private:
    static constexpr unsigned a = 16807; // 7^5
    static constexpr unsigned m = 2147483647; // 2^31 - 1

    static constexpr unsigned s = RandomGenerator< N - 1 >::value;
    static constexpr unsigned lo = a * (s & 0xFFFF); // Multiply lower 16 bits by 16807
    static constexpr unsigned hi = a * (s >> 16); // Multiply higher 16 bits by 16807
    static constexpr unsigned lo2 = lo + ((hi & 0x7FFF) << 16); // Combine lower 15 bits of hi with lo's upper bits
    static constexpr unsigned hi2 = hi >> 15; // Discard lower 15 bits of hi
    static constexpr unsigned lo3 = lo2 + hi;

public:
    static constexpr unsigned max = m;
    static constexpr unsigned value = lo3 > m ? lo3 - m : lo3;
};

template <>
struct RandomGenerator< 0 >
{
    static constexpr unsigned value = seed;
};

template < int N, int M >
struct RandomInt
{
    static constexpr auto value = RandomGenerator< N + 1 >::value % M;
};

template < int N >
struct RandomChar
{
    static const char value = static_cast< char >(1 + RandomInt< N, 0x7F - 1 >::value);
};

template < size_t N, int K >
struct XorString
{
private:
    const char _key;
    std::array< char, N + 1 > _encrypted;

    constexpr char enc(char c) const
    {
        return c ^ _key;
    }

    char dec(char c) const
    {
        return c ^ _key;
    }

public:
    template < size_t... Is >
    constexpr __forceinline XorString(const char* str, std::index_sequence< Is... >) : _key(RandomChar< K >::value), _encrypted{ enc(str[Is])... }
    {
    }

    __forceinline decltype(auto) decrypt(void)
    {
        for (size_t i = 0; i < N; ++i) {
            _encrypted[i] = dec(_encrypted[i]);
        }
        _encrypted[N] = '\0';
        return _encrypted.data();
    }
};

//--------------------------------------------------------------------------------
//-- Note: XorStr will __NOT__ work directly with functions like printf.
//         To work with them you need a wrapper function that takes a const char*
//         as parameter and passes it to printf and alike.
//
//         The Microsoft Compiler/Linker is not working correctly with variadic 
//         templates!
//  
//         Use the functions below or use std::cout (and similar)!
//--------------------------------------------------------------------------------

static auto w_printf = [](const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    vprintf_s(fmt, args);
    va_end(args);
};

static auto w_printf_s = [](const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    vprintf_s(fmt, args);
    va_end(args);
};

static auto w_sprintf = [](char* buf, const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    vsprintf(buf, fmt, args);
    va_end(args);
};

static auto w_sprintf_s = [](char* buf, size_t buf_size, const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    vsprintf_s(buf, buf_size, fmt, args);
    va_end(args);
};

#define XorStr( s ) ( XorCompileTime::XorString< sizeof( s ) - 1, __COUNTER__ >( s, std::make_index_sequence< sizeof( s ) - 1>() ).decrypt() )

END_NAMESPACE
于 2020-02-10T10:15:11.167 回答
-1

您可以使用DexGuard加密字符串，这可能比您手动实现的效率更高，而且不会增加源代码的负担。

于 2016-02-20T00:28:45.830 回答