但是我们不会在任何应用中使用 PKI 或 LPKI。相反，我们将试图找到一个平衡点，并以一种适合移动计算环境的有限资源的方式使用来自密码学的技术。因此，让我们检查一下我们希望密码学如何适应我们的应用。正如我在前面章节中提到的，保护你的用户数据是至关重要的。如果你回头看一下第二章中关于联系对象加密的例子，你能确定我们使用的是什么类型的密钥吗？我们使用了高级加密标准 (AES)算法。这是一个对称密钥算法，因为加密和解密只有一个密钥。如果你仔细观察，你会开始质疑我使用一个随机的 256 位密钥的合理性。你可能会问，如果我们一开始只是用一个随机密钥来加密数据，我们如何解密数据？我希望你在第二章的结尾的练习中回答了这个问题。如果您还没有，那么让我们现在就着手解决这个问题。

对称密钥算法

AES 是对称密钥算法 或分组密码。正如我们所见，这意味着在加密和解密中只使用一个密钥。算法用于加密或解密数据。如何处理这些数据导致了对称算法的进一步划分。例如，我们可以一次处理固定数量的数据位，称为数据块；或者我们可以一次处理一位数据，称为流。这种区别给了我们分组密码和流密码。通常，AES 被认为是对 128 位长的数据组进行操作的分组密码。128 位长的明文块将具有相同长度的密文块。AES 允许 0 到 256 位的密钥大小。在我们的例子中，我们使用了最大密钥大小。对于这本书，我将使用 AES 分组密码。我已经在表 5-3 中包含了一些 Android 自带的其他著名的分组密码。为其他分组密码生成密钥的原理与清单 5-1 中的一样，在下一节中显示。只需将 AES 的 key generator . getinstance()方法中的算法名称替换为表中列出的一种分组密码。

表 5-3 。可以在 Android 2.3.3 中使用的分组密码

密钥生成

密钥是加密技术不可或缺的一部分。大多数现代加密算法都需要密钥才能正常工作。在我们第二章的例子中，我使用了一个伪随机数发生器(PRNG)来生成我们的加密密钥(见清单 5-1 )。我使用的一个好的经验法则是总是选择算法的最大密钥大小。如果我在测试时发现我的应用严重滞后，那么我会将密钥减小到下一个更小的值。在密码学中，你总是希望为你的算法使用尽可能大的密钥长度。这样做的原因是为了更难对您的密钥进行暴力攻击。

为了说明，让我们假设您选择了 16 位的密钥大小。这意味着攻击者必须尝试 1 和 0 的组合总共 2 ¹⁶ 或 65，536 次。然而，如果你选择了完整的 256 位密钥大小，那么攻击者必须进行 2 次 ²⁵⁶ 或 11.6 次 ⁷⁷ (1.16e77)尝试来破解你的密钥，这将花费他几年的时间。当然，这个持续时间可以随着计算能力的进步而减少，但这在密码分析的所有领域都是如此。因此，大的密钥大小和强大的算法确保了攻击者不能轻易破坏您的密文。

在大多数情况下，加密数据对追求唾手可得的果实的攻击者起着威慑作用。他们不会花时间去破解你的密码，而是会转向下一个容易被攻击的应用 — ，当然，前提是你的数据的价值不会超过攻击者愿意为破解你的密码而投入的时间、精力和资源的价值。

注意当攻击者通过基于不同字符集(如 A-Z、A-Z、0-9 和特殊字符)的组合连续创建和尝试密码，不断尝试猜测正确的密码时，就会发生对密钥或密码的暴力攻击。最终，在尝试所有可能的组合的过程中，她很可能猜出正确的密码。

我知道一些开发人员仍然认为加密密钥等同于密码。不是的。不完全是。在我们的密钥生成示例中，我们使用一个随机的 256 位密钥。一般来说，这些加密程序都发生在幕后；而且虽然用户密码可以变成密钥，但我不建议这么做。避免这样做的一个原因是，用户密码几乎总是不超过 10 到 12 个字节，这甚至还不到密钥长度的一半(256 / 8 = 32 个字节)。根据我们对暴力攻击的了解，最好选择允许的最大密钥长度。

清单 5-1。 一种密钥生成算法

**public static****byte[]** generateKey(byte[] randomNumberSeed) {
                SecretKey sKey  =  null;
                **try** {
                     KeyGenerator keyGen  =  KeyGenerator.*getInstance*("AES");
                     SecureRandom random  =  SecureRandom.*getInstance*("SHA1PRNG");
                     random.setSeed(randomNumberSeed);
                     keyGen.init(256,random);
                     sKey  =  keyGen.generateKey();
                } **catch** (NoSuchAlgorithmException e) {
                     Log.*e*(*TAG*,"No such algorithm exception");
                }
                **return** sKey.getEncoded();
        }

数据填充

到目前为止，我已经讨论了处理固定数据块大小的对称算法。但是，当您的数据小于算法要求的输入块大小时会出现什么情况呢？考虑图 5-2 中的情况。这里，我们有两个数据块，但其中只有一个包含完整的块大小(为了简化，我们将使用 8 字节的块大小)；第二个仅包含 4 位。如果我们用 AES 算法运行这最后一块，它会失败。为了应对这种情况，有几种不同的填充选项可用。

图 5-2 两个数据块没有正确对齐

当你遇到图 5-2 中的情况时，你的第一个想法可能是用零填充剩余的 4 位。这是可能的，被称为零填充。存在其他不同的填充选项。在这一点上，我不会说得太详细，但是你需要记住，你不能简单地将明文通过分组密码。分组密码总是以固定的输入块大小工作，并且总是具有固定的输出块大小。图 5-3 和 5-4 显示了零填充和 PKCS5/7 填充的例子。

图 5-3 。两个带零填充的数据块。填充以粗体显示。

图 5-4 。具有 PKCS5/7 填充的两个数据块。填充以粗体显示。

注意 PKCS5/7 填充是取需要填充的剩余位的长度，并将其用作填充位。例如，如果还剩下 10 位来将块填充到正确的大小，则填充位为 0A(十六进制为 10)。类似地，如果有 28 位要填充，那么填充位将是 1C。

我在第二章中的例子没有指定任何填充。默认情况下，Android 将使用 PKCS5 填充。

分组密码的操作模式

分组密码有各种加密和解密机制。最简单的加密形式是将一个明文块加密成一个密文块。然后对下一个明文块进行加密，得到下一个密文块，依此类推。这被称为电子代码簿(ECB)模式。 图 5-5 显示了 ECB 加密的可视化表示。

图 5-5 。ECB 加密(维基百科提供)

尽管简单，ECB 模式并不能防止模式识别密码分析。这意味着如果消息文本包含两个相同的明文块，那么也将有两个对应的密文块。进行密码分析时，使用的技术之一是识别和定位密文中的模式。在模式被识别之后，可以更容易地推断出使用了 ECB 加密，因此，攻击者只需要专注于解密密文的特定块。他不需要解密整个消息。

为了防止这种情况，分组密码有几种其他的操作模式: 1) 密码分组链接(CBC)2)传播密码分组链接(PCBC)3)密码反馈(CFB)和 4) 输出反馈(OFB)。在这一节中，我只介绍加密例程(只需颠倒加密模式中的步骤就可以得到解密例程):

• CBC 模式 : 密码块链接模式(见图 5-6 )使用一个称为初始化向量 (IV)的附加值，该值用于对第一个明文块执行 XOR 运算。在此之后，每个结果密文块与下一个明文块进行异或运算，依此类推。这种类型的模式确保每个结果密文块依赖于前一个明文块。【??

  

  图 5-6 CBC 加密（维基百科提供)

• PCBC 模式 : 传播密码块链接模式(见图 5-7 )与 CBC 模式非常相似。不同之处在于，PCBC 模式不是仅对第一块的 IV 和后续块的密文进行异或运算，而是对第一块的 IV 和密文进行异或运算，然后对附加块的明文和密文进行异或运算。这种模式的设计使得密文中的微小变化会在整个加密或解密过程中传播。【??

  

  图 5-7 PCBC 加密（维基百科提供)

• *模式 : 密码反馈模式(参见图 5-8 )在 CBC 模式的 IV 和明文之间切换位置。因此，不是将明文异或并加密，随后将密文与明文异或；CFB 模式将首先加密 IV，然后将其与明文进行 XOR 运算以获得密文。然后，对于后续的块，密文再次被加密，并与明文进行异或运算，以给出下一个密文块。

  

  图 5-8T19 .中心纤维体加密（维基百科提供

  )*
  ** *模式 : 输出反馈模式(见图 5-9 )与 CFB 模式非常相似。不同之处在于，它不是使用 XORd IV 和密文，而是在 xor 运算发生之前使用。因此，对于第一个块，IV 用密钥加密，并用作下一个块的输入。然后，来自第一块的密文与第一块明文进行异或运算。在 xor 运算之前，使用前一个块的密文进行后续加密。【??

  

  图 5-9OFB 加密（维基百科提供)**

注 XOR (用符号^表示)是逻辑运算异或(又称异或)的标准缩写。其真值表如下:

0 ^ 0 = 0

0 ^ 1 = 1

1 ^ 0 = 1

1 ^ 1 = 0

如果您查看我的原始示例，您会发现我没有使用特定的加密模式。默认情况下，Android 将使用 ECB 模式来执行加密或解密。作为开发人员，您可以选择更复杂的加密模式，如 CBC 或 CFB。

现在，您对 AES 对称算法的内部工作原理有了更多的了解，我将向您展示如何在加密时更改填充和操作模式。回到我们最初的例子，将代码改为与清单 5-2 中的相同。请注意粗体代码行。我们只做了几处改动。首先我们把 AES 改成了 AES/CBC/pkcs 5 padding；其次，我们将初始化向量(IV)添加到我们的 init() 方法中。正如我之前提到的，当您只指定 AES 编码时，Android 将使用的默认模式是 AES/ECB/PKCS5Padding。您可以通过运行程序两次来验证这一点，一次使用 AES，一次使用 AES/ECB/PKC5Padding。两者都会给你相同的密文。

清单 5-2。 用 CBC 加密模式重做加密程序

private static byte[] encrypt(byte[] key, byte[] data, byte[] iv){
                SecretKeySpec sKeySpec  =  new SecretKeySpec(key,"AES");
                Cipher cipher;
                byte[] ciphertext  =  null;
                try {
                     **cipher**  =  **Cipher.getInstance("AES/CBC/PKCS5Padding");**
                     **IvParameterSpec ivspec**  =  **new IvParameterSpec(iv);**
                     cipher.init(Cipher.ENCRYPT_MODE, sKeySpec, ivspec);
                     ciphertext  =  cipher.doFinal(data);
                } catch (NoSuchAlgorithmException e) {
                     Log.e(TAG,"NoSuchAlgorithmException");
                } catch (NoSuchPaddingException e) {
                     Log.e(TAG,"NoSuchPaddingException");
                } catch (IllegalBlockSizeException e) {
                     Log.e(TAG,"IllegalBlockSizeException");
                } catch (BadPaddingException e) {
                     Log.e(TAG,"BadPaddingException");
                } catch (InvalidKeyException e) {
                     Log.e(TAG,"InvalidKeyException");
             }
             return ciphertext;

        }

假设您选择了自己选择的密钥。你可以编写一个类似于清单 5-3 所示的程序，而不是使用随机数生成器来生成你的密钥。在这个清单中， stringKey 是用来加密数据的密钥。

清单 5-3。 修改了固定键值的密钥生成示例

**public static byte**[] generateKey(String stringKey) {
                **try** {
                     SecretKeySpec sks  =  **new**
                     SecretKeySpec(stringKey.getBytes(),"AES");

                } **catch** (NoSuchAlgorithmException e) {
                     Log.e(TAG,"No such algorithm exception");
                }
                **return** sks.getEncoded();
  }

```**  **Android 中的数据存储

我想在一章中涵盖密码学和数据存储的主题，因为我相信你可以将两者联系起来，提供一个更安全的应用。Android 在独立的安全环境中运行应用。这意味着每个应用将使用自己的 UID 和 GID 运行；当一个应用写入数据时，其他应用将无法读取该数据。如果您想要在应用之间共享数据，那么您将需要通过使用内容提供者来显式地启用这种共享。我可以看到你的问题正在形成:“如果 Android 已经保护了数据，为什么还要涵盖所有的加密主题？”正如我在本章开始时提到的，我们可以在 Android 安全层上建立另一层安全，只是为了那些不可预见的漏洞、病毒或木马抬头的时候。

Android 允许你使用五种不同的选项来存储数据(参见表 5-4 )。显然，您需要根据您的需求决定在哪里存储您的特定于应用的数据。

表 5-4。的机制将的数据存储在 Android 上

| 存储方法 | 描述 | 数据保密 |
| --- | --- | --- |
| 共享偏好设置 | 允许您存储原始数据类型(例如， int 、 Boolean 、 float 、 long 和 String )，这些数据类型将在整个设备会话中保持不变。即使您的应用没有运行，您的数据也将持续存在，直到设备重新启动。 | 可以设置四种隐私模式: MODE_PRIVATE 、 MODE_WORLD_READABLE 、 MODE_WORLD_WRITABLE 和 MODE_MULTI_PROCESS 。默认模式是 MODE_PRIVATE |
| 内部存储器 | 允许您将数据存储在设备的内部存储器中。通常，其他应用甚至最终用户都无法访问这些数据。这是一个私人数据存储区。存储在此处的数据即使在设备重新启动后仍将存在。当最终用户删除你的应用时，Android 也会删除你的数据。 | 可以设置三种隐私模式: MODE_PRIVATE 、 MODE_WORLD_READABLE 和 MODE_WORLD_WRITABLE 。默认模式是模式 _ 私有。 |
| 外部存储器 | 存储在这里的数据是全球可读的。设备用户和其他应用可以读取、修改和删除这些数据。外部存储器与 SD 卡或设备内部存储器(不可移动)相关联。 | 默认情况下，数据是全局可读的。 |
| SQLite 数据库 | 如果您需要为您的应用创建一个数据库来利用 SQLite 的搜索和数据管理功能，请使用 SQLite 数据库存储机制。 | 应用中的任何类都可以访问您创建的数据库。外部应用无法访问该数据库。 |
| 网络连接 | 您可以通过 web 服务远程存储和检索数据。你可以在第六章中读到更多这方面的内容。 | 基于您的 web 服务设置。 |

选择哪种机制来存储数据在很大程度上取决于您的需求。在第二章中查看我们的 Proxim 应用，我们也可以考虑将我们的数据存储在 SQLite 数据库中，因为这将使我们免于不必要地决定实施数据结构。让我们看几个例子，看看如何使用这些机制来存储和检索数据。

共享偏好设置

共享偏好设置对于储存应用设置非常有用，这些设置在设备重新启动之前一直有效。顾名思义，存储机制最适合保存用户对应用的偏好。假设我们必须存储关于电子邮件服务器的信息，我们的应用需要从该服务器检索数据。我们需要存储邮件服务器的主机名、端口以及邮件服务器是否使用 SSL。我已经给出了存储(见清单 5-4 )和检索(见清单 5-5)数据到共享首选项的基本代码。 StorageExample1 类将所有这些放在一起(参见清单 5-6 )，伴随的输出显示在图 5-10 中。

***清单 5-4。*** 将 数据存储到 SharedPreferences 的代码

```java
package net.zenconsult.android;

import java.util.Hashtable;

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.preference.PreferenceManager;

public class StoreData {
        public static boolean storeData(Hashtable data, Context ctx) {
                SharedPreferences prefs  =  PreferenceManager
                     .getDefaultSharedPreferences(ctx);
                String hostname  =  (String) data.get("hostname");
                int port  =  (Integer) data.get("port");
                boolean useSSL  =  (Boolean) data.get("ssl");
                Editor ed  =  prefs.edit();
                ed.putString("hostname", hostname);
                ed.putInt("port", port);
                ed.putBoolean("ssl", useSSL);
                return ed.commit();
        }
}

清单 5-5。 从 SharedPreferences 中检索 数据的代码

package net.zenconsult.android;

import java.util.Hashtable;

import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;

public class RetrieveData {
        public static Hashtable get(Context ctx) {
                String hostname  =  "hostname";
                String port  =  "port";
                String ssl  =  "ssl";

                Hashtable data  =  new Hashtable();
                SharedPreferences prefs  =  PreferenceManager
                     .getDefaultSharedPreferences(ctx);
                data.put(hostname, prefs.getString(hostname, null));
                data.put(port, prefs.getInt(port, 0));
                data.put(ssl, prefs.getBoolean(ssl, true));
                return data;
        }
}

清单 5-6。 StorageExample1，主类

package net.zenconsult.android;

import java.util.Hashtable;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.widget.EditText;

public class StorageExample1Activity extends Activity {
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);
                Context cntxt  =  getApplicationContext();

                Hashtable data  =  new Hashtable();
                data.put("hostname", "smtp.gmail.com");
                data.put("port", 587);
                data.put("ssl", true);

                if (StoreData.storeData(data, cntxt))
                     Log.i("SE", "Successfully wrote data");
                else
                     Log.e("SE", "Failed to write data to Shared Prefs");

                EditText ed  =  (EditText) findViewById(R.id.editText1);
                ed.setText(RetrieveData.get(cntxt).toString());
        }

}

图 5-10T3。StorageExample1 应用的输出

内存储器

正如我们所见， SharedPreferences 非常适合键值对数据类型。这有点类似于一个散列表或者甚至是标准的 Java 属性对象。 SharedPreferences 机制的限制是您只能存储原始数据类型。你将无法存储更复杂的类型，如向量或哈希表。如果你想存储原始类型之外的数据，你可以看看内存。内部存储机制将允许您通过输出流写入数据。因此，任何可以序列化为字节字符串的对象都可以写入内部存储。让我们首先创建我们的 StorageExample2 类(参见清单 5-7 )。和以前一样，我在单独的清单中展示了存储和检索模块(分别参见清单 5-8 和清单 5-9 )。图 5-11 显示了输出。

清单 5-7。 StorageExample2，主类

package net.zenconsult.android;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.widget.EditText;

public class StorageExample2Activity extends Activity {
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);

                Context ctx  =  getApplicationContext();

                // Store data
                Contact contact  =  new Contact();
                contact.setFirstName("Sheran");
                contact.setLastName("Gunasekera");
                contact.setEmail("sheran@zenconsult.net");
                contact.setPhone("  +  12120031337");

                StoreData.storeData(contact.getBytes(), ctx);

                // Retrieve data

                EditText ed  =  (EditText) findViewById(R.id.editText1);
                ed.setText(new String(RetrieveData.get(ctx)));

        }
}

清单 5-8。 使用 StoreData.java 将数据存储在内部存储器中

package net.zenconsult.android;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.content.Context;
import android.util.Log;

public class StoreData {
        public static final String file  =  "contacts";

        public static void storeData(byte[] data, Context ctx) {

                try {
                     FileOutputStream fos  =  ctx.openFileOutput(file, ctx.MODE_PRIVATE);
                     fos.write(data);
                     fos.close();
                } catch (FileNotFoundException e) {
                     Log.e("SE2", "Exception: "  +  e.getMessage());
                } catch (IOException e) {
                     Log.e("SE2", "Exception: "  +  e.getMessage());
                }
        }
}

清单 5-9。 使用 RetrieveData.java 从内存中检索数据

package net.zenconsult.android;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import android.content.Context;
import android.util.Log;

public class RetrieveData {
        public static final String file  =  "contacts";

        public static byte[] get(Context ctx) {
                byte[] data  =  null;
                try {
                     int bytesRead  =  0;
                     FileInputStream fis  =  ctx.openFileInput(file);
                     ByteArrayOutputStream bos  =  new ByteArrayOutputStream();
                     byte[] b  =  new byte[1024];
                     while ((bytesRead  =  fis.read(b)) !  =  -1) {
                     bos.write(b, 0, bytesRead);
                     }
                     data  =  bos.toByteArray();

                } catch (FileNotFoundException e) {
                     Log.e("SE2", "Exception: "  +  e.getMessage());
                } catch (IOException e) {
                     Log.e("SE2", "Exception: "  +  e.getMessage());
                }
                return data;
        }

}

图 5-11T3。StorageExample2 应用的输出

注意清单 5-7 中的使用了 Proxim 示例中旧的联系人对象来存储数据。

SQLite 数据库

我将跳过外部存储的例子，因为您已经知道如何在外部存储数据(例如，看看 Proxim 应用的源代码)。它将其所有数据存储在外部存储器中。相反，让我们关注如何使用 Android 的 SQLite 数据库对象创建、存储和检索数据。我将创建一个数据库表，我们可以用它来存储来自 Proxim 应用的联系人对象。表 5-5 显示了工作台的布局。我采取了简单的方法，将所有列指定为文本。当您创建自己的表时，请确保根据您的数据类型指定数字、日期或时间列。

表 5-5。Contacts db SQLite 数据库中的联系人表 ??

在您的开发环境中创建一个名为 StorageExample3 的新项目，其结构如图 5-12 所示。如果需要联系人对象，从 Proxim 示例中复制它。

图 5-12T3。存储示例 3 项目结构

StorageExample3 类显示了使用 SQLite 数据库的主类 ，创建了一个包含数据的联系人对象(参见清单 5-10 )。清单 5-11 显示了一个可以用来操作 SQLite 数据库的助手类，而清单 5-12 显示了如何使用一个类将数据从 Contact 对象写入数据库。最后，图 5-13 展示了如何从 SQLite 数据库中获取数据并返回一个联系对象。一旦您有机会仔细阅读这些清单，我们将仔细看看这段代码的每一部分是做什么的，以及它是如何做到的。

清单 5-10。存储示例 3

package net.zenconsult.android;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.EditText;

public class StorageExample3Activity extends Activity {
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);

                // Store data
                Contact contact  =  new Contact();
                contact.setFirstName("Sheran");
                contact.setLastName("Gunasekera");
                contact.setEmail("sheran@zenconsult.net");
                contact.setPhone("  +  12120031337");

                ContactsDb db  =  new ContactsDb(getApplicationContext(),"ContactsDb",null,1);
                Log.i("SE3",String.valueOf(StoreData.store(db, contact)));

                Contact c  =  RetrieveData.get(db);

                db.close();

                EditText ed  =  (EditText)findViewById(R.id.editText1);
                ed.setText(c.toString());

        }
}

清单 5-11。ContactsDB 助手类 处理我们的 SQLite 数据库

package net.zenconsult.android;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase.CursorFactory;

public class ContactsDb extends SQLiteOpenHelper {
        public static final String tblName  =  "Contacts";

        public ContactsDb(Context context, String name, CursorFactory factory,
                     int version) {
                super(context, name, factory, version);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
                String createSQL  =  "CREATE TABLE "  +  tblName
                     + " ( FIRSTNAME TEXT, LASTNAME TEXT, EMAIL TEXT,"
                     + " PHONE TEXT, ADDRESS1 TEXT, ADDRESS2 TEXT);";
                db.execSQL(createSQL);
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
                // Use this to handle upgraded versions of your database
        }
}

清单 5-12。StoreData 类 将数据从联系人对象写入数据库

package net.zenconsult.android;

import android.content.ContentValues;
import android.database.sqlite.SQLiteDatabase;

public class StoreData {
        public static long store(ContactsDb db, Contact contact) {
                // Prepare values
                ContentValues values  =  new ContentValues();
                values.put("FIRSTNAME", contact.getFirstName());
                values.put("LASTNAME", contact.getLastName());
                values.put("EMAIL", contact.getEmail());
                values.put("PHONE", contact.getPhone());
                values.put("ADDRESS1", contact.getAddress1());
                values.put("ADDRESS2", contact.getAddress2());

                SQLiteDatabase wdb  =  db.getWritableDatabase();
                return wdb.insert(db.tblName, null, values);
        }
}

清单 5-13。retrieve Data 类 从 SQLite 数据库中获取数据并返回一个联系对象

package net.zenconsult.android;

import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

public class RetrieveData {
        public static Contact get(ContactsDb db) {
                SQLiteDatabase rdb  =  db.getReadableDatabase();
                String[] cols  =  { "FIRSTNAME", "LASTNAME", "EMAIL", "PHONE" };
                Cursor results  =  rdb.query(db.tblName, cols, "", null, "", "", "");

                Contact c  =  new Contact();
                results.moveToLast();
                c.setFirstName(results.getString(0));
                c.setLastName(results.getString(1));
                c.setEmail(results.getString(2));
                c.setPhone(results.getString(3));
                return c;
        }
}

图 5-13T3。StorageExample3 应用的输出

根据我的经验，我很少不得不使用平面文件来存储数据。除非我处理纯二进制数据(例如，照片、视频或音乐)，否则我存储的大部分数据要么以键值对的形式存储，要么存储在 SQLite 数据库中。因此，我可以使用 Android 的 SharedPreferences 或 SQLiteDatabase 来做这件事。这两种机制都提供了非常好的可管理性，这是对我最大的吸引力。如果您以前没有使用过 SQLite 数据库，那么您可能需要考虑更深入地了解它。事实上，大多数现代移动操作系统，包括苹果的 iOS 和 RIM 的黑莓智能手机操作系统，都提供了对 SQLite 数据库的原生支持。好的一面是 SQLite 数据库非常便于移植，您可以在几乎任何主流操作系统上创建、读取和修改 SQLite 数据库，包括 Mac OS X、Linux 和 Windows。

让我们分析一下 StorageExample3 项目的源代码。清单 5-10 是主类，它创建了一个联系人对象，其中包含数据:

Contact contact  =  new Contact();
contact.setFirstName("Sheran");
contact.setLastName("Gunasekera");
contact.setEmail("sheran@zenconsult.net");
contact.setPhone("  +  12120031337");

接下来，它使用了 ContactsDb 类 ( 清单 5-11 )，该类子类化了 SQLiteOpenHelper 类:

ContactsDb db  =  new ContactsDb(getApplicationContext(),"ContactsDb",null,1);

如果你想创建自己的数据库，那么子类化 SQLiteOpenHelper 是一个不错的选择。然后，代码使用 StoreData 类的(清单 5-12 ) store() 方法保存刚刚创建的联系人对象。我们调用 store() 方法，并传递我们新创建的 SQLite 数据库和我们的 Contact 对象。 StoreData 将把联系人对象分解成内容值对象:

ContentValues values  =  new ContentValues();
values.put("FIRSTNAME", contact.getFirstName());
values.put("LASTNAME", contact.getLastName());
values.put("EMAIL", contact.getEmail());
values.put("PHONE", contact.getPhone());
values.put("ADDRESS1", contact.getAddress1());
values.put("ADDRESS2", contact.getAddress2());

提示如果您正在创建自己的数据对象，并且您知道您将使用 SQLite 数据库机制来存储您的数据，您可能想要考虑为您的数据对象扩展 ContentValues 。这使得在存储和检索数据时更容易传递给。

接下来，我们将这些值写入数据库表。 SQLiteOpenHelper 对象可以检索一个可写数据库或者一个可读数据库。当从表中插入或查询数据时，我们使用最合适的方法:

SQLiteDatabase wdb  =  db.getWritableDatabase();
return wdb.insert(db.tblName, null, values);

RetrieveData 类处理从数据库中检索数据。这里，我们只对插入的最后一行值感兴趣。在生产应用中，我们将迭代我们的光标来获取每一行:

SQLiteDatabase rdb  =  db.getReadableDatabase();
String[] cols  =  { "FIRSTNAME", "LASTNAME", "EMAIL", "PHONE" };
Cursor results  =  rdb.query(db.tblName, cols, "", null, "", "", "");

从表中获取数据后，我们重新创建一个返回的 Contact 对象:

Contact c  =  new Contact();
results.moveToLast();
c.setFirstName(results.getString(0));
c.setLastName(results.getString(1));
c.setEmail(results.getString(2));
c.setPhone(results.getString(3));
return c;

输出(见图 5-13 )看起来和前面的例子一样。

将数据存储与加密相结合

在这一章中，我们讨论了两个非常重要的问题，但是我们是分开讨论的。如果你尝试了第二章中的练习，那么你已经对我们下一步需要做什么有了一个公平的想法。我们可以清楚地看到，无论我们选择哪种存储机制，我们存储的任何数据都被放置在明文中。我们可以依靠 Android 来确保我们的数据不被未经授权的应用读取，但如果下周一种全新的病毒被释放到野外怎么办？这种病毒只影响 Android 手机，能够绕过 SQLite 数据库权限，读取设备上的所有数据库。现在，您保持数据隐私的唯一希望已经被破坏，您的所有数据都很容易被从您的设备上复制下来。

我们在前面的章节中讨论了这种攻击，并将它们归类为间接攻击。它们是间接的，因为病毒不会直接攻击您的应用。相反，它盯上了 Android 操作系统。目的是复制所有 SQLite 数据库，希望病毒作者可以复制存储在那里的任何敏感信息。然而，如果你增加了另一层保护，那么病毒作者看到的将是乱码数据。让我们构建一个可以在所有应用中重用的更永久的加密库。让我们首先创建一组简短的规范 :

• 使用对称算法:我们的库将使用对称算法或分组密码来加密和解密我们的数据。我们将解决 AES，虽然我们应该能够在以后修改它。
• 使用固定密钥:我们需要能够包含一个可以存储在设备上的密钥，用于加密和解密数据。
• 存储在设备上的密钥:密钥将驻留在设备上。虽然从直接攻击的角度来看，这对我们的应用来说是一个风险，但它应该足以保护我们免受间接攻击。

让我们从我们的密钥管理模块开始(参见清单 5-14 )。因为我们计划使用一个固定的密钥，所以我们不需要像在过去的例子中那样生成一个随机的密钥。因此按键管理器将执行以下任务:

1. 接受一个键作为参数( setId(byte[] data) 方法)
2. 接受一个初始化向量作为参数( setIv(byte[] data) 方法)
3. 将密钥存储在内部存储区的文件中
4. 从内部存储的文件中检索密钥(方法 getId(byte[] data)
5. 从内部存储的文件中检索 IV(方法 getIv(byte[] data)

清单 5-14。 按键管理器模块

package net.zenconsult.android.crypto;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.content.Context;
import android.util.Log;

public class KeyManager {
        private static final String TAG  =  "KeyManager";
        private static final String file1  =  "id_value";
        private static final String file2  =  "iv_value";

        private static Context ctx;

        public KeyManager(Context cntx) {
                ctx  =  cntx;
        }

        public void setId(byte[] data) {
                writer(data, file1);
        }

        public void setIv(byte[] data) {
                writer(data, file2);
        }

        public byte[] getId() {
                return reader(file1);
        }

        public byte[] getIv() {
                return reader(file2);
        }
        public byte[] reader(String file) {
                byte[] data  =  null;
                try {
                     int bytesRead  =  0;
                     FileInputStream fis  =  ctx.openFileInput(file);
                     ByteArrayOutputStream bos  =  new ByteArrayOutputStream();
                     byte[] b  =  new byte[1024];
                     while ((bytesRead  =  fis.read(b)) !  =  -1) {
                     bos.write(b, 0, bytesRead);
                     }
                     data  =  bos.toByteArray();
                } catch (FileNotFoundException e) {
                     Log.e(TAG, "File not found in getId()");
                } catch (IOException e) {
                     Log.e(TAG, "IOException in setId(): "  +  e.getMessage());
                }
                return data;
        }

        public void writer(byte[] data, String file) {
                try {
                     FileOutputStream fos  =  ctx.openFileOutput(file,
                     Context.MODE_PRIVATE);
                     fos.write(data);
                     fos.flush();
                     fos.close();
                } catch (FileNotFoundException e) {
                     Log.e(TAG, "File not found in setId()");
                } catch (IOException e) {
                     Log.e(TAG, "IOException in setId(): "  +  e.getMessage());
                }
        }

}

接下来，我们做加密模块(见清单 5-15 )。这个模块负责加密和解密。我在模块中添加了一个 armorEncrypt() 和 armorDecrypt() 方法，以便更容易地将字节数组数据转换为可打印的 Base64 数据，反之亦然。

清单 5-15。 密码模块

package net.zenconsult.android.crypto;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import android.content.Context;
import android.util.Base64;

public class Crypto {
        private static final String engine  =  "AES";
        private static final String crypto  =  "AES/CBC/PKCS5Padding";
        private static Context ctx;

        public Crypto(Context cntx) {
                ctx  =  cntx;
        }

        public byte[] cipher(byte[] data, int mode)
                     throws NoSuchAlgorithmException, NoSuchPaddingException,
                     InvalidKeyException, IllegalBlockSizeException,
                     BadPaddingException, InvalidAlgorithmParameterException {
                KeyManager km  =  new KeyManager(ctx);
                SecretKeySpec sks  =  new SecretKeySpec(km.getId(), engine);
                IvParameterSpec iv  =  new IvParameterSpec(km.getIv());
                Cipher c  =  Cipher.getInstance(crypto);
                c.init(mode, sks, iv);
                return c.doFinal(data);
        }

        public byte[] encrypt(byte[] data) throws InvalidKeyException,
                     NoSuchAlgorithmException, NoSuchPaddingException,
                     IllegalBlockSizeException, BadPaddingException,
                     InvalidAlgorithmParameterException {
                return cipher(data, Cipher.ENCRYPT_MODE);
        }

        public byte[] decrypt(byte[] data) throws InvalidKeyException,
                     NoSuchAlgorithmException, NoSuchPaddingException,
                     IllegalBlockSizeException, BadPaddingException,
                     InvalidAlgorithmParameterException {
                return cipher(data, Cipher.DECRYPT_MODE);
        }

        public String armorEncrypt(byte[] data) throws InvalidKeyException,
                     NoSuchAlgorithmException, NoSuchPaddingException,
                     IllegalBlockSizeException, BadPaddingException,
                     InvalidAlgorithmParameterException {
                return Base64.encodeToString(encrypt(data), Base64.DEFAULT);
        }
        public String armorDecrypt(String data) throws InvalidKeyException,
                     NoSuchAlgorithmException, NoSuchPaddingException,
                     IllegalBlockSizeException, BadPaddingException,
                     InvalidAlgorithmParameterException {
                return new String(decrypt(Base64.decode(data, Base64.DEFAULT)));
        }

}

您可以在任何需要加密数据存储的应用中包含这两个文件。首先，确保您的密钥和初始化向量有一个值，然后在存储数据之前对数据调用任何一种加密或解密方法。清单 5-16 显示了对 StorageExample3 类所需的更改。此外，清单 5-17 和 5-18 分别显示了对 StoreData 和 RetrieveData 文件所需的更改。

清单 5-16。 新存储例 3 带加密

package net.zenconsult.android;

import net.zenconsult.android.crypto.Crypto;
import net.zenconsult.android.crypto.KeyManager;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.EditText;

public class StorageExample3Activity extends Activity {
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);

                String key  =  "12345678909876543212345678909876";
                String iv  =  "1234567890987654";

                KeyManager km  =  new KeyManager(getApplicationContext());
                km.setIv(iv.getBytes());
                km.setId(key.getBytes());

                // Store data
                Contact contact  =  new Contact();
                contact.setFirstName("Sheran");
                contact.setLastName("Gunasekera");
                contact.setEmail("sheran@zenconsult.net");
                contact.setPhone("  +  12120031337");

                ContactsDb db  =  new ContactsDb(getApplicationContext(), "ContactsDb",
                     null, 1);
                Log.i("SE3", String.valueOf(StoreData.store(new Crypto(
                     getApplicationContext()), db, contact)));

                Contact c  =  RetrieveData.get(new Crypto(getApplicationContext()), db);

                db.close();

                EditText ed  =  (EditText) findViewById(R.id.editText1);
                ed.setText(c.toString());

        }
}

清单 5-17。 修改 StoreData 类

package net.zenconsult.android;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import net.zenconsult.android.crypto.Crypto;
import android.content.ContentValues;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

public class StoreData {
        public static long store(Crypto crypto, ContactsDb db, Contact contact) {
                // Prepare values
                ContentValues values  =  new ContentValues();
                try {
                     values.put("FIRSTNAME", crypto.armorEncrypt(contact.getFirstName()
                     .getBytes()));
                     values.put("LASTNAME", crypto.armorEncrypt(contact.getLastName()
                     .getBytes()));
                     values.put("EMAIL", crypto.armorEncrypt(contact.getEmail()
                     .getBytes()));
                     values.put("PHONE", crypto.armorEncrypt(contact.getPhone()
                     .getBytes()));
                     values.put("ADDRESS1", contact.getAddress1());
                     values.put("ADDRESS2", contact.getAddress2());
                } catch (InvalidKeyException e) {
                     Log.e("SE3", "Exception in StoreData: "  +  e.getMessage());
                } catch (NoSuchAlgorithmException e) {
                     Log.e("SE3", "Exception in StoreData: "  +  e.getMessage());
                } catch (NoSuchPaddingException e) {
                     Log.e("SE3", "Exception in StoreData: "  +  e.getMessage());
                } catch (IllegalBlockSizeException e) {
                     Log.e("SE3", "Exception in StoreData: "  +  e.getMessage());
                } catch (BadPaddingException e) {
                     Log.e("SE3", "Exception in StoreData: "  +  e.getMessage());
                } catch (InvalidAlgorithmParameterException e) {
                     Log.e("SE3", "Exception in StoreData: "  +  e.getMessage());
                }
                SQLiteDatabase wdb  =  db.getWritableDatabase();
                return wdb.insert(ContactsDb.tblName, null, values);
        }
}

清单 5-18。 修改后的检索数据类

package net.zenconsult.android;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import net.zenconsult.android.crypto.Crypto;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

public class RetrieveData {
        public static Contact get(Crypto crypto, ContactsDb db) {
                SQLiteDatabase rdb  =  db.getReadableDatabase();
                String[] cols  =  { "FIRSTNAME", "LASTNAME", "EMAIL", "PHONE" };
                Cursor results  =  rdb.query(ContactsDb.tblName, cols, "", null, "", "",
                     "");

                Contact c  =  new Contact();
                results.moveToLast();

                try {
                     c.setFirstName(crypto.armorDecrypt(results.getString(0)));
                     c.setLastName(crypto.armorDecrypt(results.getString(1)));
                     c.setEmail(crypto.armorDecrypt(results.getString(2)));
                     c.setPhone(crypto.armorDecrypt(results.getString(3)));
                } catch (InvalidKeyException e) {
                     Log.e("SE3", "Exception in RetrieveData: "  +  e.getMessage());
                } catch (NoSuchAlgorithmException e) {
                     Log.e("SE3", "Exception in RetrieveData: "  +  e.getMessage());
                } catch (NoSuchPaddingException e) {
                     Log.e("SE3", "Exception in RetrieveData: "  +  e.getMessage());
                } catch (IllegalBlockSizeException e) {
                     Log.e("SE3", "Exception in RetrieveData: "  +  e.getMessage());
                } catch (BadPaddingException e) {
                     Log.e("SE3", "Exception in RetrieveData: "  +  e.getMessage());
                } catch (InvalidAlgorithmParameterException e) {
                     Log.e("SE3", "Exception in RetrieveData: "  +  e.getMessage());
                }

                return c;
        }
}

图 5-14 显示了任何人在没有解密信息的情况下访问 SQLite 数据库的会是什么样子。为了复制这个，我没有让 RetrieveData 类解密任何数据。

图 5-14T3。如果不解密，数据会是什么样子

摘要

在这一章中，我们讲述了密码学的基础知识。我们研究了 PKI 和可信第三方是如何工作的，以及对于我们的目的来说，PKI 甚至 LPKI 是如何变得多余的。然后，我们看了加密数据的简单机制，并学习了术语。我们看到加密不像选择对称算法那样简单，您必须考虑不同的方面，如填充和操作模式。

然后我们看了 Android 上存储数据的各种机制。我们讨论了每一个例子，并选择 SQLite 数据库和 SharedPreferences 来存储应用数据。然后，我们研究了如何使用加密来混淆我们的数据，我们构建了一个通用库来执行加密和解密。这个库可以包含在我们未来需要以安全的方式存储数据的任何程序中。**

六、与网络应用交互

在某些时候，您将不得不与 web 应用进行交互。无论您是与第三方的 RESTful API 对话，还是与您自己的后端 web 应用交换数据，您的移动应用都需要接受与其他应用交互的想法。当然，作为一个负责任的开发人员，您的工作是确保数据交换完成，这样攻击者就不能访问或更改属于最终用户的私有数据。在前面的章节中，当我们研究数据存储和加密时，我们花了时间来探索“静态数据”。在本章中，我们将讨论“传输中的数据”

最初，我不打算花太多时间讨论加密传输中的数据的好处。通常，SSL 或 TLS 将处理传输中数据的安全部分。然而，最近对荷兰 DigiNotar 认证机构的入侵让我重新考虑这个选项(更多信息见 http://en.wikipedia.org/wiki/DigiNotar 的 )。最后，作为开发人员，我将让您来决定如何保护您的传输数据；但是很明显，最近的这次攻击让我想到，即使信任 SSL 也不总是最好的选择。因此，我将介绍一些与 web 应用安全性相关的主题，以及您的移动应用应该如何与这样的 web 应用进行交互。我还将简要介绍开放 Web 应用安全项目(OWASP );这是保护您的 web 应用的一个非常好的资源。

考虑清单 6-1 中的源代码有多安全。现在问问你自己，你会做些什么来使它更安全？(查看本章末尾的解决方案，并比较您自己的笔记，看看您的思路是否正确。)

清单 6-1 。 客户端登录

package net.zenconsult.android.examples;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import android.util.Log;

public class Login {
  private final String TAG = "HttpPost";

  public Login() {

  }

  public HttpResponse execute() {
       HttpClient client = new DefaultHttpClient();
       HttpPost post = new HttpPost(" [`logindemo1.appspot.com/logindemo`](http://logindemo1.appspot.com/logindemo)");
       HttpResponse response = null;

       // Post data with number of parameters
       List  <  NameValuePair  >       nvPairs = new ArrayList  <  NameValuePair  >  (2);
       nvPairs.add(new BasicNameValuePair("username", "sheran"));
  nvPairs.add(new BasicNameValuePair("password", "s3kretc0dez"));

       // Add post data to http post
       try {
       UrlEncodedFormEntity params = new UrlEncodedFormEntity(nvPairs);
       post.setEntity(params);
       response = client.execute(post);

       } catch (UnsupportedEncodingException e) {
       Log.e(TAG, "Unsupported Encoding used");
       } catch (ClientProtocolException e) {
       Log.e(TAG, "Client Protocol Exception");
       } catch (IOException e) {
       Log.e(TAG, "IOException in HttpPost");
       }
       return response;
       }

}

准备我们的环境

让我们从设置测试环境开始。我们显然需要一个现成的 web 应用托管基础设施。当我需要快速部署或测试 web 应用时，我通常依赖 Google App Engine。这为我节省了很多时间，而且我不必担心设置硬件、web 服务器和应用服务器。有了 Google App Engine，我可以用最小的设置开销开始编码。

让我们首先在 Google App Engine 上注册一个帐户(如果您已经有了 Gmail 的 Google 帐户，那么您可以跳过以下步骤使用它):

1. 导航到(参见图 6-1 )。

   

   图 6-1T14 .谷歌应用引擎主页

2. 点击注册链接。出现提示时，使用您的 Gmail 帐户登录。然后你将被带到你的应用列表(见图 6-2 )。

   

   图 6-2T13 .应用列表

3. 单击创建应用按钮。下一页允许您选择有关您的应用的详细信息。(参见图 6-3 )。由于您的应用将公开可见，Google 为您提供了一个子域。appspot.com。这个子域池在应用引擎开发者的整个用户群中共享；因此，在某些情况下，您可能收不到您想要的应用名称。例如，你不太可能收到登录域名 1 子域名，因为我已经注册了。您可以通过单击“检查可用性”按钮来检查子域的可用性。

   

   图 6-3T14 .为您的应用命名

4. 填写你想要的应用的子域；应该是类似 < 你的名字>ogindemo 1. appspot . com(见图 6-3 )。给你的应用一个标题，比如登录演示 1。保持其余选项不变，然后单击 Create Application。

5. 如果一切顺利，您将会看到一个类似于图 6-4 的页面，告诉您您的应用已经成功创建。接下来，您可以通过单击“dashboard”链接来查看您的应用的状态。你的应用还没有做任何事情，所以统计数据仍然是空的(见图 6-5 )。

图 6-4 。成功创建应用 ??

图 6-5 。应用仪表板

接下来，您必须下载用于 Google App Engine 的 SDK，以便在将应用发布到 Google App Engine 服务器之前，您可以在本地计算机上编写、运行和调试应用。我在大部分开发中使用 Eclipse，我将概述下载 SDK 并将其直接与 Eclipse 集成所需的步骤。此外，由于我们正在覆盖 Android，我们将坚持 Java SDK 的应用引擎。

你可以在以下网址找到如何安装 Eclipse 的 Google Apps 插件的详细说明:code.google.com/eclipse/docs/getting_started.html。即使最终的 URL 发生了变化，您也应该能够通过导航到基本 URL，即 http://code.google.com/eclipse 的，到达文档部分。

我们还不打算写任何后端代码。首先，让我们编写一个存根应用，我们可以从它开始并在其上进行构建。在您的 Eclipse IDE 中，通过转到 FileNewWeb Application Project 来创建一个新的 Google App Engine 项目。将项目名填写为 LoginDemo，将包名填写为 net.zenconsult.gapps.logindemo，取消选中使用 Google Web Toolkit 旁边的复选框(参见图 6-6 )。完成后，点按“完成”。您将最终得到一个名为 LoginDemo 的项目；在命名的包中，您会发现一个名为的文件。该文件包含清单 6-2 中的代码。目前，它没有什么特别的。代码等待一个 HTTP GET 请求，然后用纯文本进行响应:“Hello，world。”

图 6-6 创建一个新的谷歌应用引擎项目

清单 6-2 。 默认存根应用包 ，net . Zen consult . gapps . logindemo

import java.io.IOException;
import javax.servlet.http.*;

@SuppressWarnings("serial")
public class LoginDemoServlet extends HttpServlet {
  public void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws IOException {
            resp.setContentType("text/plain");
            resp.getWriter().println("Hello, world");
  }

}

让我们将这个应用部署到 Google App Engine，看看我们能否通过 web 浏览器访问它。要部署应用，在 Eclipse 包管理器中右键单击它，然后单击 Google Deploy to App Engine。

然后会提示您选择您在 Google 网站上创建的远程应用的名称。在应用 ID 字段中输入您创建的名称(参见图 6-7 )并点击确定。在下一个窗口中，单击 Deploy 将您的应用上传到 Google(参见图 6-8 )。

图 6-7 。选择远程应用的名称

图 6-8 。将应用部署到 Google

成功部署应用后，您可以通过导航到创建应用时选择的 URL(<yourname>log in demo 1 . appspot . com)来检查应用。在我的例子中，当我导航到 http://logindemo1.appspot.com 的，时，我会看到“你好，世界”响应消息(参见图 6-9 )。

图 6-9 。访问登录 servlet

我们现在有了自己的工作 web 应用，可以随心所欲地使用它。你可能已经注意到设置一个 Google App Engine 应用是多么的方便。这无疑节省了我们构建服务器、安装操作系统、安装服务器软件和配置服务器的时间和精力。让我们来看一些与 web 应用相关的理论。

HTML、网络应用和网络服务

任何 web 开发人员都知道 HTML 是什么。它是任何现代网站的基本组成部分之一。HTML(超文本标记语言)始于 1991 年的一份草稿；这是一种非常简单的语言，可以用来创建基本的网页。快进到 2008 年，HTML 版本 5 的草案发布了。纯 HTML 页面 被称为静态页面。换句话说，它们呈现在最终用户的浏览器上，并保持在那里，直到用户导航到另一个页面。

一个网络应用 是终端用户通过网络 — 访问的一个软件，就像 HTML 页面一样。然而，web 应用比普通的 HTML 包含更多的动态元素。例如，现代网络应用有许多服务器端语言。这些语言(例如 PHP、JSP 和 ASP)在运行时根据最终用户的输入动态生成静态 HTML。web 应用安装在 web 服务器上，并托管在最终用户可以通过网络(如互联网)访问的硬件上。服务器端应用框架负责呈现用户界面、任何应用逻辑(例如，搜索、计算或任何其他过程)以及数据存储或检索功能。最终用户所要做的就是带着他最喜欢的网络浏览器出现在聚会上。换句话说，因为所有复杂的处理都发生在后端或服务器端，所以更薄、更轻的 web 浏览器只不过是一种与用户界面交互的机制。

网络应用为开发者提供了许多优势 并且是当今网络生活中无处不在的一部分。它们最大的优势之一是能够向服务器推出更新或补丁，而不必担心更新成百上千的客户端。web 应用的另一大优势是，最终用户只需要一个瘦客户端——web 浏览器——仅此而已。因此，您不仅可以接触到来自个人计算群体的大量用户，还可以接触到移动计算群体。

一个 web 服务 类似于一个 web 应用，因为它可以通过网络远程访问。它的相似之处还在于它也运行某种服务器软件。然而，主要的区别是用户不能交互地访问服务。在大多数情况下，web 服务与其他客户端或服务器应用进行交互。在大多数情况下，web 服务能够描述它提供的服务以及其他应用如何访问它们。它使用 Web 服务描述语言(WSDL)文件来完成这项工作。其他应用可以通过处理发布的 WSDL 文件来了解如何使用 web 服务。通常，web 服务使用特定的 XML 格式来交换信息。其中一个流行的协议是 SOAP(简单对象访问协议)。SOAP 由基于特定应用的各种 XML 有效载荷组成。清单 6-3 显示了一个 SOAP 消息的例子。

清单 6-3 。 一个 SOAP 消息的例子(由维基百科提供)

POST /InStock HTTP/1.1
Host:[www.example.org](http://www.example.org)
Content-Type: application/soap  +  xml; charset = utf-8
Content-Length: 299
SOAPAction: "[`www.w3.org/2003/05/soap-envelope`](http://www.w3.org/2003/05/soap-envelope)"

“1.0”？>

>

>

IBM

web 服务的另一种工作方式是公开 RESTful API。REST 或表述性状态转移是一种架构，它使用底层的、无状态的客户端-服务器协议来公开 web 服务的端点。REST 的前提是使用一种简单得多的访问介质(如 HTTP ),对每个资源使用单独的 URIs，而不是依赖更复杂的协议，如 SOAP(使用单个 URI 和多个参数)。

你可以在罗伊·菲尔丁的学位论文www . ics . UCI . edu/∞Fielding/pubs/disserious/REST _ arch _ style . htm或维基百科的en . Wikipedia . org/wiki/representative _ state _ transfer上阅读更多关于 REST 的内容。尽管使用 RESTful web 服务很简单，但它仍然可以执行与使用 SOAP 的 web 服务相同的任务。以清单 6-3 中的 SOAP 为例。如果我们的 web 服务将它作为 RESTful API 公开给我们，那么我们会做这样的事情:

 [`www.example.com/stocks/price/IBM`](http://www.example.com/stocks/price/IBM) 

请注意，这是请求的范围。它可以作为一个简单的 HTTP GET 请求发送给服务器，然后服务器可以做出响应。有时，服务器可以用几种不同的表示形式返回数据。例如，如果我们向服务器请求 XML 输出，我们可以添加一个扩展 xml 。如果我们想要 JSON 格式的，我们可以添加一个 json 扩展名，如下所示:

 [`www.example.com/stocks/price/IBM.xml`](http://www.example.com/stocks/price/IBM.xml) 
 [`www.example.com/stocks/price/IBM.json`](http://www.example.com/stocks/price/IBM.json) 

现在是谈论 HTTP(超文本传输协议)的好时机。HTTP 是驱动 web 的协议。虽然超文本最初指的是普通的老式 HTML，但现在可以扩展到包括 XML(可扩展标记语言)。XML 遵循 HTTP 的规则，但是它包括可以使用的自定义 HTML 标签(或关键字)。HTTP 作为一种请求-响应协议。请求-响应循环发生在称为客户端和服务器的两方之间。客户端，或者说用户代理(一个网络浏览器)，向网络服务器发出请求，网络服务器返回一个 HTML 或者 XML 的响应。大多数经验丰富的 web 开发人员有时也会期待与 XML 类似的格式，比如 JSON(JavaScript Object Notation)。

HTTP 请求被进一步细分为请求类型，或方法 。有几种方法，最常用的是 GET 和 POST 。 GET 请求用于检索数据， POST 请求用于提交数据。如果你正在填写注册表格，点击提交按钮会提示浏览器将你的数据发送到服务器。如果你回头看本章开头的清单 6-1 ，你会看到这一行:

HttpPost post = new HttpPost(" [`logindemo1.appspot.com/logindemo`](http://logindemo1.appspot.com/logindemo) ");

这是对特定 URL 的 HTTP POST 请求的创建。您可能知道，URL(统一资源定位器)是一种地址，它告诉用户代理从哪里检索特定的资源。资源可以是远程存储在服务器上的文件、文档或对象。HTTP 请求和响应都有相似的结构。两者都包含标题和内容区域。你可以在 www.w3.org 的 ?? 找到很多关于 HTTP 的附加信息。

Web 应用中的组件

Web 应用由不同的层组成。典型的 web 应用有三层(见图 6-10 ):表示层、逻辑层和数据层。根据应用的要求和复杂性，层数可能会增加。拥有多层应用有许多优势:其中之一是系统所有者可以独立于其他层替换或扩展硬件或服务器配置。考虑公司需要增加数据存储量的情况；IT 部门可以升级这一层，而无需对其他层进行重大更改。下一个优势是安全团队可以在每一层进行更精细的控制。每一层都有不同的功能，因此有不同的要求和相关的安全控制。多层应用允许所有者在各个层拥有更多锁定的控制，而不是留下空白，因为所有三层都在一个系统上。

因此，基于三层架构 ，一个 web 应用将包含一个呈现其数据的 web 服务器，一个处理所有数据交换请求的应用服务器，以及一个存储和检索数据的数据库服务器。

图 6-10T3。一个三层的网络应用(由维基百科提供)

让我们通过一个例子来看看每一层是如何涉及的。

登录流程

客户端与服务器进行的标准用户身份验证会话如下所示:

1. 客户端从 web 服务器【Web 服务器/表示层】请求登录页面。
2. 客户端将凭证发送到 web 服务器【Web 服务器/表示层】。
3. 应用服务器接收数据并检查其是否符合验证规则【应用服务器/逻辑层】。
4. 如果数据是好的，那么应用服务器查询数据库服务器以发现是否存在匹配的凭证【应用服务器/逻辑层】。
5. 数据库服务器响应应用服务器成功或失败【数据库服务器/数据层】。
6. 应用服务器告诉 web 服务器向客户端提供其门户(如果凭证正确)或错误消息(如果凭证不匹配)【应用服务器/逻辑层】。
7. Web 服务器显示来自应用服务器【Web 服务器/表示层】的消息。

虽然这是一个简化的示例，但它确实说明了流程如何从外部移动到内部 — ，然后再返回。

Web App 技术

web 应用的每一层都可以使用多种技术。您可以从许多 web 服务器、应用框架、应用服务器、服务器端脚本语言和数据库服务器中进行选择。您的选择标准取决于多种因素，如应用要求、预算以及对您选择的技术的支持的可用性。

因为 Android 开发主要是在 Java 上完成的，所以我决定在我们的 web 应用中也坚持使用 Java。除了 Java，您还可以使用其他服务器端技术。这里列举了其中的一些:

• PHP:www.php.net
• python:www.python.org
• 决哥: www .决哥 project.com
• perl:(不太常用，但有时仍会使用)
• 冷聚变:www.adobe.com/product/coldfusion-family.html
• ASP。净:
• ruby on Rails:www.rubyonrails.org

类似地，根据您的需求，您可以将许多流行的数据库用于您的数据层应用。存在许多免费的和商业的数据库。这是您或您的应用架构师最初必须做出的又一个决定。这里有一个流行数据库的简短列表和一个 URL ,表明您可以在哪里了解更多关于它们的信息:

• Oracle:www . Oracle . com
• 微软 SQL Server:www.microsoft.com/sqlserver
• MySQL:www.mysql.com
• PostgreSQL:www.postgresql.org
• couch db:couchdb.apache.org
• 莽哥布:www .mon 哥布. org

现在让我们花几分钟时间来完成我们的 web 应用，以便它支持基本的密码检查。请注意，我故意让这个例子非常简单。实际 web 应用的身份验证例程将更加复杂。查看清单 6-4 中的代码。

清单 6-4 。 新的凭证验证码

package net.zenconsult.gapps.logindemo;

import java.io.IOException;
import javax.servlet.http.*;

@SuppressWarnings("serial")
public class LoginDemoServlet extends HttpServlet {
  private String username = "sheran";
  private String password = "s3kr3tc0dez"; // Hardcoded here intended to
  // simulate a database fetch

  public void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws IOException {
    resp.setContentType("text/plain");
  resp.getWriter().println("Hello, world");
  }

  public void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws IOException {
    String user = req.getParameter("username"); // No user input validation
                                                    // here!
    String pass =   req.getParameter("password"); // No user input validation
                                                    // here!

    resp.setContentType("text/plain");
    if (user.equals(username) && pass.equals(password)) {
      resp.getWriter().println("Login success!!");
    } else {
      resp.getWriter().println("Login failed!!");
      }

    }
}

下一步是发布您的代码，就像您第一次设置 Google App Engine 帐户时所做的那样，然后创建一个新的处理身份验证的 Android 项目(项目结构见图 6-11 )。清单 6-5、 6-6、 6-7、和 6-8 分别包含了登录、登录民主客户端 1 活动、字符串. xml 和 main.xml 文件的源代码。确保将这一行添加到您的 AndroidManifest.xml 文件中，因为您将需要访问互联网来访问您的 Google App Engine 应用:

<uses-permission Android:name =【Android . permission . internet】>

图 6-11T3。项目结构

清单 6-5 。 登录类

package net.zenconsult.android.examples;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import android.util.Log;

public class Login {
  private final String TAG = "HttpPost";
  private String username;
  private String password;

  public Login(String user, String pass) {
       username = user;
       password = pass;
  }

  public HttpResponse execute() {
       Log.i(TAG, "Execute Called");
       HttpClient client = new DefaultHttpClient();
       HttpPost post = new HttpPost("[`logindemo1.appspot.com/logindemo`](http://logindemo1.appspot.com/logindemo)");
       HttpResponse response = null;

       // Post data with number of parameters
       List< NameValuePair  >       nvPairs = new ArrayList  <  NameValuePair  >  (2);
       nvPairs.add(new BasicNameValuePair("username", username));
       nvPairs.add(new BasicNameValuePair("password", password));

       // Add post data to http post
  try {
            UrlEncodedFormEntity params = new UrlEncodedFormEntity(nvPairs);
            post.setEntity(params);
            response = client.execute(post);
            Log.i(TAG, "After client.execute()");

       } catch (UnsupportedEncodingException e) {
       Log.e(TAG, "Unsupported Encoding used");
       } catch (ClientProtocolException e) {
            Log.e(TAG, "Client Protocol Exception");
       } catch (IOException e) {
            Log.e(TAG, "IOException in HttpPost");
  }
  return response;
  }

}

6-5 中列出的代码包含登录程序。类构造函数 Login 有两个参数，分别是用户名和密码。 execute() 方法 将使用这些参数向服务器发出 HTTP POST 请求。

清单 6-6 。logindemoclient 1 活动类

package net.zenconsult.android.examples;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class LoginDemoClient1Activity extends Activity implements
  OnClickListener {
  private final String TAG = "LoginDemo1";
  private HttpResponse response;
  private Login login;

  /** Called when the activity is first created. */
  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);

      Button button =     (Button) findViewById(R.id.login);
      button.setOnClickListener(this);

  }

  @Override
  public void onClick(View v) {
      String u = ((EditText) findViewById(R.id.username)).toString();
      String p = ((EditText) findViewById(R.id.password)).toString();

      login = new Login(u, p);

      String msg = "";
      EditText text =         (EditText) findViewById(R.id.editText1);
  text.setText(msg);

  response = login.execute();
      Log.i(TAG, "After login.execute()");

      if (response ! = null) {
  if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
      try {
  BufferedReader reader =     new BufferedReader(
  new InputStreamReader(response.getEntity()
  .getContent()));
  StringBuilder sb =     new StringBuilder();
  String line;
      while ((line = reader.readLine()) ! = null) {
  sb.append(line);
  }
  msg = sb.toString();
  } catch (IOException e) {
  Log.e(TAG, "IO Exception in reading from stream.");
      }

  } else {
      msg = "Status code other than HTTP 200 received";
  }
  } else {
  msg = "Response is null";
  }
      text.setText(msg);
  }
}

6-6 中列出的代码是一个标准的 Android 活动。这可以被认为是应用的入口或起点。

清单 6-7 。strings . XML 文件

<?xml version = "1.0" encoding = "utf-8"?>
<resources>
  <string name = "hello"  >  Web Application response:</string>
  <string name = "app_name"  >  LoginDemoClient1</string>
  <string name = "username"  >  Username</string>
  <string name = "password"  >  Password</string>
  <string name = "login"  >  Login</string>
</resources>

清单 6-8 。main . XML 文件

<?xml version = "1.0" encoding = "utf-8"?>
<LinearLayout xmlns:android = " [`schemas.android.com/apk/res/android`](http://schemas.android.com/apk/res/android) "
  android:orientation = "vertical"
  android:layout_width = "fill_parent"
  android:layout_height = "fill_parent"
  android:weightSum = "1">
  <TextView android:textAppearance = "?android:attr/textAppearanceLarge"
  android:id = "@  +  id/textView1" android:layout_height = "wrap_content"
  android:layout_width = "wrap_content" android:text = "@string/username">
  </TextView>
<EditText android:layout_height = "wrap_content"
  android:layout_width = "match_parent" android:id = "@  +  id/username">
</EditText>
<TextView android:textAppearance = "?android:attr/textAppearanceLarge"
  android:id = "@  +  id/textView2" android:layout_height = "wrap_content"
  android:layout_width = "wrap_content" android:text = "@string/password">
</TextView>
<EditText android:layout_height = "wrap_content"
  android:layout_width = "match_parent" android:inputType = "textPassword"
  android:id = "@  +  id/password">
</EditText>
<Button android:text = "@string/login" android:layout_height = "wrap_content"
  android:layout_width = "166dp" android:id = "@  +  id/login">
</Button>
<TextView android:text = "@string/hello" android:layout_height = "wrap_content"
  android:layout_width = "fill_parent">
</TextView>
<EditText android:id = "@  +  id/editText1" android:layout_height = "wrap_content"
  android:layout_width = "match_parent" android:inputType = "textMultiLine"
  android:layout_weight = "0.13">
  <requestFocus  >  </requestFocus>
</EditText>
</LinearLayout>

strings.xml 和 main 。 xml 文件分别包含我们定义的字符串常量集和应用的图形布局。

运行您的应用并输入不同的用户名和密码。您应该会看到两条不同的响应消息，一条表示成功，另一条表示密码失败(参见图 6-12 )。就是这样！您已经完成了移动登录客户端和服务器的编写。接下来，我们将讨论 web 上的安全性，以及在您的 web 应用中可能会遇到的各种攻击。

图 6-12T3。登录失败

OWASP 和网页攻击

开放 web 应用安全项目(OWASP)【www.owasp.org】是一个为测试和保护 Web 应用提供大量知识、技术和指南的组织。OWASP 成立于 2001 年 12 月，并于 2004 年获得美国非营利慈善机构地位。它的核心目标是"成为一个蓬勃发展的全球社区，推动全球软件安全性的可见性和发展。“这是了解和修复 web 应用安全性的绝佳资源。

OWASP 十大项目自 2004 年以来一直是 OWASP 基金会 的子项目。在半定期的基础上，OWASP 十大漏洞列出了十个最重要的应用安全漏洞。这些漏洞被列为项目成员和全球安全专家在 web 应用中所经历的广泛共识。十大清单被大量商业组织使用和采纳，它已经成为 web 应用安全的事实标准。

在这本书出版的时候，2010 年 OWASP 十大仍然是最近更新的名单 。这里可以找到:【www.owasp.org/index.php/Top_10_2010】??。

下面列出了 2010 年 OWASP 十大主题:

• A1:注射
• A2:跨站点脚本(XSS)
• A3:不完整的认证和会话管理
• A4:不安全的直接对象引用
• A5:跨站点请求伪造(CSRF)
• A6:安全错误配置
• A7:不安全的加密存储
• A8:无法限制 URL 访问
• A9:传输层保护不足
• A10:未经验证的重定向和转发

较新的 OWASP 项目之一是移动十大，它是 OWASP 移动安全项目 的一部分。该项目仍在开发中，在撰写本文时还没有发布最终的清单。然而，网站上有一个实用技巧的列表，将证明对你这个移动开发者有巨大的帮助。本章涵盖的大多数主题都与移动十大共享许多技术和原则。以下是该列表涵盖的主题:

• 识别和保护移动设备上的敏感数据。
• 在设备上安全地处理密码凭证。
• 确保敏感数据在传输过程中受到保护。
• 正确实施用户认证/授权和会话管理。
• 保持后端 API(服务)和平台(服务器)的安全。
• 安全地执行与第三方服务/应用的数据集成。
• 特别注意收集和存储同意收集和使用用户数据。
• 实施控制以防止对付费资源(如钱包、短信和电话)的未授权访问。
• 确保移动应用的安全分发/供应。
• 仔细检查代码的任何运行时解释是否有错误。

认证技术

现在，让我们继续讨论保护“传输中的数据”的主题。我希望你对 web 应用的幕后工作有一个公平的理解，这就是为什么我在本章中讨论了与 web 应用相关的主题。如果你致力于成为一名移动应用开发人员，那么看看你的应用如何与你想与之交流的 web 应用进行通信是很有趣的。更好地理解应用还可以帮助您提高安全性和性能。如果像我一样，您从头到尾都在编写代码，包括 web 应用开发，那么您可能已经熟悉了我将要讨论的主题。不管怎样，既然您已经对 web 应用和安全性有了一个简短的回顾，那么让我们继续手头的主要任务。

身份验证是需要与远程 web 应用交互的移动应用的一个重要特性。几乎所有当今的应用都依赖某种形式的用户名和密码或 PIN 组合来授权对其数据的访问。用户名和密码存储在服务器上，每当最终用户希望通过应用进行身份验证时，就会进行比较。如果你重新看一下清单 6-1，你会发现我们正在这么做。以下几行包含 web 应用的用户名和密码:

nvPairs.add(new BasicNameValuePair("username", "sheran"));
nvPairs.add(new BasicNameValuePair("password", "s3kretc0dez"));

在这种情况下，信息是硬编码的，但它可以很容易地存储在设备上(当然是加密的！)并在用户想要登录时检索。但是如果我们的流量在传输过程中被拦截了呢？“啊哈！但是我们有 SSL！”你说。这是真的，但是我们似乎没有在我们的例子中使用它，因为我们的 POST 请求发送到一个非 SSL/TLS 端口:

HttpPost post = new HttpPost(" [`logindemo1.appspot.com/logindemo`](http://logindemo1.appspot.com/logindemo) ");

好吧，那是个卑鄙的手段。但是我们认真考虑一下，我们的 SSL 流量被攻破了。窃听我们与 web 应用对话的攻击者现在可以访问我们的凭据。她现在要做的就是直接在完整的网络应用或另一个移动设备上使用它们。如果她这样做，她将完全控制我们的用户资料。如果这是一个社交网站，那么我们可能不会太在意；然而，如果这是我们的网上银行应用，那么我们会非常担心。

到目前为止，我们知道在进行远程身份认证时面临的风险。尽管我们的数据可能会通过安全通道，但仍然容易受到攻击。而且不一定是像 DigiNotar 事件那样的严重攻击，攻击者可以颁发她自己的证书。例如，攻击可能像 SSL 中间人攻击一样平淡无奇。

因为我不止一次提到 DigiNotar 和不信任 SSL，所以我认为我概述一下我的理由是公平的。

你不能总是相信 SSL 。一般来说，最终用户认为 SSL 意味着他们是安全的。浏览器上的挂锁图标和地址栏变成绿色表示您正在浏览一个安全的网站。然而，这不一定是真的。我想花点时间回顾一下 SSL 的一些概念。

SSL(安全套接字层)是一种传输协议，它对两台计算机之间传输的数据进行加密。一个窃听者不可能不经过一番努力就截获加密数据——。因此，SSL 确保数据在客户端和服务器计算机之间保持私密。SSL 已经过时了。大多数人把客户端和服务器之间的加密 HTTP 数据传输称为 SSL 但实际上，较新的协议是 TLS(传输层安全)。SSL 和 TLS 不可或缺的一部分是 X.509 证书。X.509 是公钥基础设施(PKI)的标准，我在第五章中简单介绍过。通常，用户会将 X.509 服务器证书称为 SSL 证书。这是 SSL 的一个关键且非常重要的组件。图 6-13 显示了设置 SSL 会话的浏览器。

图 6-13T3。设置 SSL/TLS 会话

TLS 和 SSL 结合使用加密技术来确保数据传输的安全性。现在让我们来看看这个会话设置。我不会给你外科手术的细节，因为你几乎永远不需要写自己的 TLS 协商算法。相反，本节将让您了解如何设置加密以及在 TLS 会话期间发生了什么。

首先，客户端或浏览器将联系 web 服务器并向其发送一些信息。该信息包含它可以支持的 TLS 版本的详细信息和加密算法列表。这些被称为密码套件 ，它们包含支持各种任务的算法，如密钥交换、认证和批量密码。

接下来，服务器在选择了它支持的特定密码套件以及客户机和服务器都支持的最高通用 TLS 版本后做出响应。然后，服务器还会向客户端发送其 SSL 证书。

然后，客户端使用服务器的公钥加密并交换一个预主密钥，一个生成主密钥的密钥。

交换预主密钥后，客户端和服务器将使用随机值和预主密钥来生成最终的主密钥。这个主密钥存储在客户端和服务器上。

然后，服务器和客户端切换到加密所有来回发送的数据。使用选定的密码套件，并在两端使用对称主密钥来加密和解密数据。图 6-14 显示了如果您能够捕获客户端和服务器之间的加密数据会话，您会看到什么。图 6-15 显示了使用 OpenSSL 查看时的握手和其他相关细节。只要看一眼就会立即告诉您，绝对没有可供攻击者使用的数据。那么，这对开发人员来说意味着什么呢？您应该使用 SSL，并且在客户机和服务器之间交换敏感数据时永远不用担心被窥探？我暂时不会接受你的回答。我们先来看几个细节，稍后再来回答你。

图 6-14T3。SSL 会话的流量捕获

图 6-15T3。使用 OpenSSL 的 s_client 选项查看 SSL 握手

SSL 与信任息息相关。实际上，X.509 是关于信任的。SSL 证书是根据特定标准颁发给个人或公司的。颁发机构，也称为 CA 或证书颁发机构，负责确定您是否是您所说的那个人。例如，你不能只申请一个 www.google.com 证书而不证明你以某种方式隶属于该公司，或者有能力代表该公司行事。这很重要，因为如果 CA 不检查这些凭证，那么任何人都可以申请 SSL 证书并将其安装在自己的 web 服务器上。

通过欺骗最终用户，让他们相信你的服务器是 google.com 服务器，你可以实施中间人攻击，拦截他的所有数据。我们很快会看到中间人攻击；但是首先，我想介绍另一个您可能知道的话题，即自签名证书。

注意CA 向客户端颁发 SSL 证书。颁发证书时，CA 还将使用自己的根证书对 SSL 证书进行签名。这个签名表明 CA 信任发布的 SSL 证书。浏览器可以通过首先查看 CA 签名并验证签名是否与根证书匹配来验证 SSL 证书。

世界各地都有许多知名的根 ca。通常，CA 根证书打包在您的 web 浏览器中。这允许浏览器验证由不同 ca 颁发的 SSL 证书。

例如，假设您向 VeriSign 申请了您的域名、example.com 的证书。VeriSign 首先确定您是该域的正确所有者，然后为您的 web 服务器颁发证书。它用自己的根证书签署该证书。收到 SSL 证书后，您可以将其安装在 web 服务器上并建立您的网站。现在当我访问您的网站时，我的浏览器首先查看您的 SSL 证书，然后尝试验证您的证书是否确实是由受信任的 CA 颁发的。为此，我的浏览器将查看其可信根证书的内部存储，以确定 VeriSign 根证书的签名是否与您的证书上的签名匹配。如果是的话，我可以继续浏览你的网站。但是，如果难以验证您的证书，我的浏览器会警告我无法验证证书。

请注意，在给证书开绿灯之前，您的浏览器将验证关于证书的许多其他细节。

自签名证书

在一些项目的开发和测试阶段，开发人员有时会在他们的网站上使用自签名证书。这种类型的证书在所有方面都与 CA 颁发的 SSL 证书相同。但是，主要的区别在于该证书上的签名不是来自可信的 CA。相反，开发人员自己签署证书。当浏览器使用自签名 SSL 证书连接到站点时，它无法验证谁签署了证书。这是因为签名者没有列在浏览器的内部可信证书库中。然后浏览器会向用户发出类似于图 6-16 中所示的警告。

图 6-16T3。不可信或自签名证书的警告

发生在浏览器上的验证阶段非常重要。它的存在使得攻击者不能简单地给自己颁发一个属于的证书来欺骗用户。如果浏览器无法验证 SSL 证书，它将始终提醒用户。

中间人攻击

中间人(MitM) 攻击是一种攻击者可以窃听双方之间的网络流量或数据流动的方法。攻击者将自己定位成能够拦截来自发送方和接收方的流量，有效地将自己置于两者之间(见图 6-17 )。在这个位置上，他能够在双方之间截取和传递信息。如果执行正确，会话两端的用户都不会知道攻击者在中继和拦截他们的流量。

图 6-17T3。艾丽丝和鲍勃中间的马洛里(维基百科提供)

下面是一个 MitM 攻击的例子，使用图 6-17 作为参考 ??:

Alice "Hi Bob, it's Alice. Give me your key"--> Mallory Bob
Alice Mallory "Hi Bob, it's Alice. Give me your key"--> Bob
Alice Mallory <--[Bob's_key] Bob
Alice <--[Mallory's_key] Mallory Bob
Alice "Meet me at the bus stop!"[encrypted with Mallory's key]--> Mallory Bob
Alice Mallory "Meet me in the windowless van at 22nd Ave!"encrypted with Bob's![image
 key]--> Bob

大多数时候，我们看到的攻击都集中在自签名证书上，或者诱骗浏览器相信攻击者拥有有效的证书。直到最近，攻击者对 CA 安全知之甚少，涉及 CA 的事件也少得多。不管怎么说，直到 2011 年 6 月之前都是如此。

理论上，攻击 CA 以获取合法签名的可信 SSL 证书也是一种选择。没有多少攻击者会考虑这一点，因为他们显然希望 CAs 具有高度的安全性。正确错了！2011 年 6 月，一个名为 DigiNotar 的 CA 遭到攻击。攻击者给自己颁发了 500 多个由 DigiNotar 签名的欺诈 SSL 证书。作为一个可信的 CA，DigiNotar 在所有现代浏览器中都有根证书。这意味着攻击者拥有合法的 SSL 证书，可以用来执行 MitM 攻击。由于浏览器已经信任 DigiNotar 根证书，它们将总是验证这些流氓 SSL 证书，最终用户永远不会知道攻击者正在拦截她的数据。

为什么会这样？DigiNotar 的基础设施安全控制非常松散。攻击者能够远程破坏其服务器，并访问负责颁发合法证书的系统。在这之后，对于攻击者来说，随时为自己颁发证书是一个相对简单的任务。一些有流氓证书的比较著名的网站 包括:

• *.google.com (指【google.com】的任何子域，包括【mail.google.com】【docs.google.com】【plus.google.com】等等)
• *.android.com
• *.microsoft.com
• *.mozilla.org
• *.wordpress.org
• www.facebook.com
• www.mossad.gov.il
• www.sis.gov.uk

所有的网页浏览器开发者都将 DigiNotar 的根证书列入黑名单，DigiNotar 开始系统地撤销所有的流氓证书。不幸的是，当这一切发生的时候，DigiNotar 已经失去了全球成千上万用户的信任。该公司于 2011 年 9 月宣布破产。

如果这么大的 CA 可以遭受这么大的安全漏洞，危及数百个 SSL 证书，那么我们真的可以一直依赖 SSL 吗？事实上，我们可以。像 DigiNotar 这样的事件很少发生，所以我会选择信任 SSL。然而，我也会选择在我的移动应用和服务器之间部署我自己的数据加密层。然后，如果 SSL 层被以任何方式破坏，攻击者将有另一层加密要处理。在大多数情况下，这一额外的层将作为一种威慑，攻击者可能会离开您的应用。

有没有一种方法可以防止攻击者在通过 SSL 传输时窥探我们的凭据？确实是的！让我们来看两种方法，即使我们的安全传输通道出现故障，我们也可以防止我们的凭据被破坏。一个是 OAuth ，一个是挑战/响应。

听觉

OAuth 协议允许被称为消费者 的第三方网站或应用使用被称为服务供应器 的网络应用上的最终用户数据。最终用户对他可以授予这些第三方的访问权限拥有最终控制权，并且这样做时不必泄露或存储他现有的 web 应用凭证。

以 Picasa 网络相册为例；照片编辑应用 Picnik(www.picnik.com)允许最终用户编辑他们的照片。Picnik 还允许终端用户从 Picasa 和 Flickr 等其他网站导入内容。在 OAuth 之前，用户必须登录 Picnik，还要输入他的 Picasa 或 Flickr 用户名和密码，这样 Picnik 就可以开始从这些网站导入照片。这种方法的问题是，现在用户已经用 Picnik 保存或使用了他的凭证。他的曝光度增加了，因为他在 Picasa 和 Picnik 保存了自己的凭证。

如果用 OAuth 重现相同的场景，那么用户就不必在 Picnik 站点上再次输入凭证。相反，Picnik(消费者)会将他重定向到他的 Picasa(服务供应器)网站(见图 6-18 )并要求他允许或拒绝访问 Picasa 上存储的照片(见图 6-19 )。这样，用户的凭证更安全。

图 6-18T3。Picnik 请求连接到 Picasa，这样它就可以请求一个访问令牌

图 6-19T3。Picasa 请求授权让 Picnik 查看一些照片

OAuth 通过使用请求令牌来工作。想要访问 web 应用中的数据的站点需要从该应用获得一个令牌，然后才能开始访问这些数据。

让我们先来看看 OAuth 是如何为 Picasa 网络相册工作的。例如，假设您编写了一个列出用户 Picasa 相册的 Android 应用。您的 Android 应用需要访问用户的 Picasa 网络相册才能做到这一点。在这种情况下，参与者是您的 Android 应用(消费者)、Picasa(服务供应器)和您的最终用户。

OAuth 要求您首先在进行身份验证的站点上注册您的消费者应用。这是必要的，因为您将收到一个需要在代码中使用的应用标识符。要注册您的应用，您必须访问【http://code.google.com/apis/console】(参见图 6-20 )，创建一个项目，并创建一个 OAuth 客户端 ID(参见图 6-21 、 6-22 、 6-23 和 6-24 )。

图 6-20T3。在 Google APIs 上创建一个新项目

图 6-21T3。创建新的客户端 ID

图 6-22T3。填写您的申请详情

图 6-23T3。选择您的申请类型

图 6-24T3。您的客户端 ID 和客户端密码现在已创建

现在你已经得到了 OAuth 客户端 ID，让我们来看看 OAuth 应用的认证流程 (见图 6-25 )

图 6-25T3。OAuth 认证流程(由 Google 提供)

OAuth 是一个包含三个主要交互方的多阶段流程。消费者是希望从服务提供者那里访问数据的应用，这只有在用户明确授权消费者的情况下才会发生。让我们详细回顾一下这些步骤:

当最终用户打开您的 Android 应用 时，会启动以下场景:

1. 流程 A: 消费者应用(您的 Android 应用)向服务供应器(Picasa)请求令牌。
2. 流程 B: Picasa 告诉您的应用将最终用户重定向到 Picasa 的网页。然后，您的应用会打开一个浏览器页面，将最终用户指引到特定的 URL。
3. 流程 C: 最终用户在该屏幕中输入她的凭证。请记住，她正在登录服务供应器(Picasa)网站，并授权访问您的应用。她将凭据发送到网站，而不是存储在设备上的任何地方。
4. 流程 D: 一旦 Picasa 确认最终用户输入了正确的用户名和密码，并授予了对您的应用的访问权限，它会回复一个响应，指示请求令牌是否已被授权。此时，您的应用必须检测到这种响应并采取相应的行动。假设授权被授予，您的应用现在有一个授权的请求令牌。
5. 流程 E: 使用这个授权的请求令牌，你的应用向服务供应器发出另一个请求。
6. 流程 F: 然后，服务提供者将请求令牌交换为访问令牌，并在响应中将其发送回去。
7. 你的应用现在使用这个访问令牌来访问任何受保护的资源(在这个例子中是用户的 Picasa 相册)，直到令牌过期。

您的应用现已成功访问 Picasa，无需存储最终用户的凭据。如果用户的手机遭到破坏，攻击者复制了所有应用数据，他将无法在您的应用数据中找到 Picasa 用户名和密码。这样，你就确保了你的应用不会不必要地泄露敏感数据。

我在这里使用 Picasa 只是作为一个参考框架。我们的最终目标是为我们的后端应用创建一个 OAuth 认证系统。因此，您的后端 web 应用 将成为 OAuth 服务提供者，而不是 Picasa 作为服务提供者。您的最终用户必须通过 web 浏览器登录到您的应用，并明确授权它访问资源。接下来，您的移动应用和后端 web 应用将使用请求和访问令牌进行通信。最重要的是，你的移动应用不会保存你的网络应用的用户名和密码。

为了说明这些概念，我为 Picasa 创建了一个示例应用。我将在第八章向你展示如何在你的 web 应用中实现 OAuth。

用密码术挑战/响应

保护您的最终用户凭证不通过 Internet 的第二种机制是使用挑战/响应技术。这种技术在许多方面与 OAuth 相似，因为没有凭证通过网络。相反，一方请求另一方挑战。然后，另一方将根据特别选择的算法和密码功能对随机信息进行加密。用于加密这些数据的密钥是用户密码。这个加密的数据被发送到质询方，然后质询方使用存储在其末端的密码对同一条信息进行加密。然后比较密文；如果匹配，则允许用户访问。学习这种技术的最好方法是通过一个实际的例子。与 OAuth 一样，我在第八章中包含了源代码和应用示例。

总结

在这一章中，我们重点讲述了如何将我们的数据从移动应用安全地传输到 web 应用。我们还介绍了如何使用成熟的协议和机制来保护传输中的数据。与此同时，我们看到，在某些情况下，我们无法信任协议本身。在这种情况下，我们会考虑一些选项，帮助我们保护最终用户的凭据不被窃取或拦截。

我们还讨论了涉及 web 应用安全性的主题。考虑到大多数移动应用以某种形式与 web 应用通信，了解这方面的技术如何工作总是有好处的。最后，我们查看了一些有助于我们保护 web 应用的有用资源，以及一些在传输过程中保护用户凭证的具体示例。

七、企业安全

一直以来，我们都是站在个人开发者的角度来看待移动应用。尽管我相信个人开发者或较小的开发公司远远超过企业开发者，但我认为关注企业开发者和他可能面临的独特挑战是有益的。你可能想跳过这一章，因为你不属于“企业开发者”的范畴；然而，我会敦促你考虑这一点:现在大多数企业都在考虑外包他们的开发工作。

对于一个企业来说，拥有一个内部的移动开发团队可能是没有意义的，除非这是公司的核心业务。我见过许多企业将开发工作外包给个人或小公司，这样他们就不用担心管理内部移动开发团队。

如果有一天，一家公司雇佣你为它开发一个移动应用，那么在你开始开发之前，你可能需要考虑几个领域。在大多数方面，你的目标群体比你向公众发布你的应用要小得多。

然而，重要的一点是，就企业而言，您可能要处理的不仅仅是个人信息的丢失。例如，在企业环境中，您处理机密信息(例如，商业秘密、公司财务信息或敏感的服务器凭证)的可能性比您处理向公众发布的应用的可能性要高得多。此外，您的应用可能会更容易成为攻击目标，因为目前许多攻击者认为移动平台由于安全性较低而“容易得手”。让我们首先来看一下企业应用与公开发布的应用的一些主要区别。

连通性

最近，从远程位置连接到企业环境已经变得司空见惯。远程办公、远程支持和外包都导致企业技术团队允许授权用户进入他们组织的网络。这并不意味着网络管理员只是让防火墙对远程登录和远程桌面敞开大门；入站连接受到某些安全控制。为了确保最安全的路由，组织通常会使用 VPN 或虚拟专用网络(见图 7-1 )，以允许远程用户加入其网络。

图 7-1 。虚拟专用网(VPN)(由维基百科提供)

VPN 通常是网络管理员通常会在其边界网络设备上创建的附加逻辑或虚拟网络。该网络充当公共网络(如互联网)和企业的私有内部网络之间的桥梁。用户可以通过这个公共网络连接到 VPN，并使用企业的内部资源(包括文件服务器、内部应用等)，就像他们实际连接到内部网络一样。

VPN 也逐渐进入移动领域。黑莓、iPhone 和 Android 等设备现在能够连接到企业网络并安全地传输数据。在为企业设计时，请记住这一点。很有可能企业网络管理员会告诉你需要使用 VPN 但是如果她没有提到，你应该提出这个话题。这里的目标不是让一个企业向互联网公开更多它不应该公开的内容。

如果出于某种原因，你遇到一个没有或没有使用 VPN 的组织，那么你可能想花一点时间讨论一下 VPN 的优点。如果这是绝对不行的，那么你将不得不对应用和服务器之间的数据进行加密。但是，请记住，这样做的成本很高，尤其是在有大量数据交换的情况下。在这种情况下，您可能还需要考虑数据压缩。在这一章的后面我会给你一个数据压缩的例子。所有这些都增加了处理器的使用，但是，你需要考虑到，在几乎所有的情况下，这将耗尽你的终端用户的设备电池。

企业应用

那么，我一直在谈论的这些企业应用是什么呢？请放心，他们不像独角兽那样神秘；他们确实存在。如果你没有太多的机会在企业中工作，那么你可能不会马上认出一个企业系统。有许多不同的类型，但这里我们将重点放在企业资源规划(ERP) 应用上，主要是因为它们往往涵盖了企业中广泛的用途。典型的 ERP 应用通常涵盖以下领域之一:

• 供应链管理
• 客户关系管理
• 制造业
• 人力资源
• 财务和会计
• 项目管理

你将不得不使用的 ERP 应用很可能是成熟的和完善的。作为新的开发人员，您还可能需要编写自己的应用来与现有系统一起工作。这可能有点令人沮丧，尤其是当这意味着您必须在移动应用的某些功能上做出妥协的时候。在我看来，解决这个问题的最好方法之一是采用和使用某种形式的移动中间件 。

移动中间件

与其让自己的移动应用与遗留的企业应用一起工作，还不如花些时间开发自己的移动中间件平台。简单地说，移动中间件平台在您的移动应用与企业系统的通信中充当中间人的角色。目标 是让您的移动应用能够处理企业应用中的数据，而不会影响操作系统功能或移动设备上可用的有限资源。

我曾经测试过一个银行手机应用的安全性。移动应用开发人员在与一个非常专有的、封闭的、文档记录不充分的应用集成时，遵循了使用移动中间件的思想。开发人员以屏幕翻译器的形式创建了一个移动中间件组件。本质上，这是一个基于服务器的应用，它将从银行应用 获取网站，挖掘或复制特定页面上的所有文本，然后将这些页面转换为移动格式的文本。

看一下图 7-2 。它展示了移动应用如何连接到一个中间件系统，该中间件系统抽象了遗留应用的数据和用户界面。在某些情况下，移动客户端可以通过移动浏览器直接访问遗留应用，但在这种情况下，它不会提供理想的用户体验。因此，通过与移动中间件接口，应用的通信基础设施可以标准化。与遗留应用的大多数交互 将在更强大的硬件上完成。

图 7-2 。移动中间件示例

考虑到这一点，当我们决定开发企业移动应用时，我们需要确定我们将会遇到的一些关键场景。在这一章中，我着眼于开发企业移动应用时被证明是一个挑战的两个领域:数据库访问 和数据表示。在移动企业应用开发过程中，这些特定的领域被证明是一个挑战。让我们从数据库访问开始。

数据库访问

Android 支持可以用来访问数据库服务器的 javax.sql 和 java.sql 包。让我们从一个非常简单但不安全的示例应用 — 开始，向您展示这种方法的不足之处。接下来，我们将看看一些更好的技术。您可能会奇怪，为什么我要浪费您的时间来详细研究一个不安全的解决方案。重点是看它为什么没有安全感；只有当你明白它是多么的不安全，你才会充分体会到正确方法的好处。随意向前跳——后果自负！

该应用将连接到一个 MySQL 数据库，并从名为 apress 的表中读取数据。为了正确执行，Android 设备和数据库服务器应该位于同一个网络上。我将把数据库的设置和创建留给您。确保您设置了数据库服务器来监听公共 IP 地址。你可以通过编辑 MySQL 安装中的 my.cnf 文件来实现。清单 7-1 包含了数据库模式。确保首先创建名为 android 的数据库。创建表格后，向其中输入一些测试数据，这样当您使用 Android 应用连接到表格时就可以检索到它。

清单 7-1。 一条 MySQL SQL 语句创建一个 apress 表

CREATE TABLE `apress` (
   `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
   `name` varchar(50) NOT NULL DEFAULT '',
   `email` varchar(50) DEFAULT NULL,
   PRIMARY KEY (`id`)
) ENGINE = MyISAM AUTO_INCREMENT = 4 DEFAULT CHARSET = latin1;

现在让我们开始开发应用吧。创建一个名为 MySQLConnect 的新项目。在您的项目文件夹中，创建一个名为 lib 的新文件夹。现在从 www.mysql.com/products/connector/下载最新版本的 MySQL Connector/J。接下来，解压存档并复制。jar 文件到您的 lib 目录。该文件应该类似于 MySQL-connector-Java-5 . 1 . 15-bin . jar。如果您正在使用 Eclipse 进行开发，那么您的项目布局将类似于图 7-3 中的布局。在我的布局中，你可以看到我有几个版本的 MySQL 连接器，但是我使用的是最新的版本。

图 7-3 。MySQLConnect 项目结构

在这个例子中，我们创建了一个列表视图布局。这为我们从数据库中检索的数据提供了一个很好的全屏列表。因为列表视图将包含单独的项目，我们必须告诉 Android 每个项目是什么。为此，我们创建一个名为 list_item.xml 的新 XML 文件，包含清单 7-2 中的文本，然后将其保存在布局文件夹下，如图 7-3 所示。

清单 7-2。list _ item . XML 文件内容

<?xml version  =  *"1.0"*encoding  =  *"utf-8"*?>
<TextView xmlns:android  =  "http://schemas.android.com/apk/res/android"
   android:layout_width  =  *"fill_parent"*
   android:layout_height  =  *"fill_parent"*
   android:padding  =  *"10dp"*
   android:textSize  =  *"16sp"*>
</TextView>

这告诉 Android 每个列表项都是文本类型的，并给它一些关于文本填充和字体大小的详细信息。接下来是 MySQLConnectActivity.java 文件的代码(见清单 7-3 )。记下将主机 IP 地址、用户名和密码更改为您创建的内容。

清单 7-3。【MySQLConnectActivity.java】源代码

package net.zenconsult.android;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Hashtable;

import android.app.ListActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

public class MySQLConnectActivity extends ListActivity {
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);

      Connection conn  =  null;
      String host  =  "192.168.3.105";
      int port  =  3306;
      String db  =  "android";

      String user  =  "sheran";
      String pass  =  "P@ssw0rd";

      String url  =  "jdbc:mysql://"  +  host  +  ":"  +  port  +  "/"  +  db  +  "?user = "
      + user  +  "&password = "  +  pass;
      String sql  =  "SELECT * FROM apress";

      try {
         Class.forName("com.mysql.jdbc.Driver").newInstance();
         conn  =  DriverManager.getConnection(url);

         PreparedStatement stmt  =  conn.prepareStatement(sql);
         ResultSet rs  =  stmt.executeQuery();
         Hashtable  < String, String  >  details  =  new Hashtable  < String, String  > ();
         while (rs.next()) {
           details.put(rs.getString("name"), rs.getString("email"));
         }
         String[] names  =  new String[details.keySet().size()];
         int x  =  0;
         for (Enumeration  < String  >  e  =  details.keys(); e.hasMoreElements();) {
           names[x]  =  e.nextElement();
           x++;
         }
         conn.close();
         this.setListAdapter(new ArrayAdapter  < String  > (this,
           R.layout.list_item, names));

         ListView lv  =  getListView();
         lv.setTextFilterEnabled(true);

         lv.setOnItemClickListener(new OnItemClickListener() {
           public void onItemClick(AdapterView  < ?  >  parent, View view,
           int position, long id) {
             Toast.makeText(getApplicationContext(),
             ((TextView) view).getText(), Toast.LENGTH_SHORT).show();
            }
         });

         } catch (ClassNotFoundException e) {
           Log.e("MYSQL", "Class not found!");
         } catch (SQLException e) {
           Log.e("MYSQL", "SQL Exception "  +  e.getMessage());
         } catch (InstantiationException e) {
           Log.e("MYSQL", "Instantiation error "  +  e.getMessage());
         } catch (IllegalAccessException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         }

   }
}

因为我们正在访问网络，你必须确保你的应用具有在 AndroidManifest.xml 文件中设置的 Android . permission . internet 权限。

保存您的项目并在您的 Android 模拟器上运行它。您的应用应该启动，连接到数据库，检索数据，并以类似于图 7-4 所示的全屏列表视图显示数据。

图 7-4 。应用正确执行时的输出

正如你所看到的，即使我们能够直接从数据库中读取数据，除了用我们的应用打包大型 JDBC 驱动程序库之外，似乎还有很多繁琐的代码需要我们编写。

在某些情况下，如果你不得不连接到一个没有纯 JDBC 驱动的数据库，那么你就被困住了。如果您考虑安全问题，那么您需要考虑您的数据库服务器必须暴露在互联网或 VPN 上，因为移动设备和数据库服务器都应该能够相互通信。最后，您可以看到数据库凭证存储在应用中。

请看下面这段代码:

Connection conn  =  null;
   String host  =  "192.168.3.105";
   int port  =  3306;
   String db  =  "android";

   String user  =  "sheran";
   String pass  =  "P@ssw0rd";
   String url  =  "jdbc:mysql://"  +  host  +  ":"  +  port  +  "/"  +  db  +  "?user = "
    + user  +  "&password = "  +  pass;
   String sql  =  "SELECT * FROM apress";

以 String user 和 String pass 开始的行显示了数据库凭证是如何在应用中被硬编码的。如果手机遭到破坏，攻击者可以从你的应用数据中读取数据库凭据，并使用它们从另一台计算机连接，直接攻击你的数据库。

因此，在你的 Android 应用中使用原生 JDBC 连接并不是最好的方法。最好编写一个移动中间件模块，让 app 以更方便、更安全的方式访问数据。

我们如何改进数据库访问过程？HTTP 是最简单也可能是最成熟的请求/响应机制之一。通过使用 HTTP ，我们当然可以简化和提高我们的数据访问方法的安全性。Android 已经内置了非常强大的 HTTP 客户端；我们有 SSL 来保护我们的数据；而且，如果需要，我们可以为来回传输的数据添加额外的加密层。你可能会说使用 HTTP 是不需要动脑筋的，所以我们就这么做吧。

但是我们应该如何使用 HTTP 从数据库中请求数据呢？我们可以使用 web 服务从后端获取数据。我们可以使用 REST(表述性状态转移)进行通信，而不是制作非常复杂的 web 服务。公开 RESTful API 将极大地简化我们的移动应用请求数据的方式。考虑这个例子:

 [`192.168.3.105/apress/members`](https://192.168.3.105/apress/members) 

通过发出这个 get 请求，我们可以获取与之前在 MySQLConnect 示例中获取的数据集相同的数据集。使用 HTTP 请求获取数据肯定要简单得多。当然，下一步是检索数据。因为我们选择了 HTTP 作为我们的传输机制，所以我们必须使用 HTTP 友好的响应机制。这就给我们带来了数据表示的问题。我们将在下一节中讨论这一点。

我希望您正在构建自己的库集，以便以后重用。这是一个很好的练习。我有几个不同的库，它们是我在开发时为不同的任务创建的。我有一个处理数据库连接的库，一个处理数据编码和解码的库，还有许多我在构建应用时使用的其他小工具库。它们加快了我的开发周期，并且通常使一切保持一致的状态。我现在提出这一点是因为，如果您打算开始构建自己的定制移动中间件的旅程，那么如果您将它设计成可以插入到尽可能多的部署场景中，您会更好。从那里，您可以调整配置设置，这样您就可以快速启动并运行。

注意自定义库

开发你自己的库是一个很好的实践。对我来说，编写自己的库意味着我永远不会忘记几个月前完成的一个特定的实现。我可以简单地调用我的共享库函数，并毫不费力地集成它。

但是，请记住，您所有的外部库函数都应该非常简单。这些基本功能以后可以串联起来执行一个复杂的功能。因此，您可以构建自己的库，并完全加快开发时间。

假设您花费了大量的时间和精力为您的客户编写一个电子商务应用。项目完成后，可能没有明确要求保留源代码。然而，如果你遇到另一个客户希望你建立一个类似的电子商务商店，这可能对你很重要。如果您对自己在早期应用中编写的代码拥有无可争议的所有权，您就可以重用它，从而大大减少准备新应用所需的时间。

数据表示

解决了这个问题之后，让我们来谈谈数据表示。通过数据表示，我指的是您的移动应用如何从后端 web 应用接收数据。在我们的案例中，我们正试图将我们的移动应用接收和处理数据的方式标准化。目前最常见的数据表示格式是 XML(可扩展标记语言)和 JSON (JavaScript 对象表示法)。因此，让我们致力于编写移动应用框架来接收和处理这种类型的数据。关于 XML 和 JSON 的快速入门，请参考附录。选择这种类型的数据表示的另一个原因是，有许多第三方的开源库，您可以根据自己的目的使用或修改。

回到我们的 RESTful API 请求，让我们看看我们可能从移动中间件得到的以下两个潜在响应:

XML
<?xml version = "1.0" encoding = "UTF-8"?>
<apress>
   <users>
    <user name = "Sheran" email =  "sheranapress@gmail.com" />
      <user name = "Kevin" email = "kevin@example.com" />
      <user name = "Scott" email = "scottm@example.com" />
   </users>
</apress>
JSON
{
   users:{
    user:[
    {
    name:'Sheran',
    email:'sheranapress@gmail.com'
    },
    {
    name:'Kevin',
    email:'kevin@example.com'
     },
    {
    name:'Scott',
    email:'scottm@example.com'
     }
     ]
  }
}

好的一面是，您不需要编写这么多代码来读取 XML 和 JSON 表示。Android 包括解析这两种格式的库。让我们看一些源代码。再次创建一个新项目，并将其命名为 RESTFetch 。像前面的例子一样创建 list_item.xml 文件，然后将 Android . permission . internet 权限分配给应用。清单 7-4 包含应用的代码，它将发出请求，处理 XML 响应，并在列表中呈现结果。图 7-5 包含输出。

清单 7-4。 使用 RESTful API 获取数据并处理 XML 输出

packagenet.zenconsult.android;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.net.URI;
import java.net.URISyntaxException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import android.app.ListActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

public class RESTFetchActivity extends ListActivity {
   @Override
   public voidonCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    BufferedReader in =  null;

    try{
    HttpClient client =  new DefaultHttpClient();
    HttpGet request =  new HttpGet();
    request.setURI(new URI("http://192.168.3.105/apress/members"));
    HttpResponse response =  client.execute(request);
    in =  new BufferedReader(new InputStreamReader(response.getEntity()
    .getContent()));
    StringBuffer sb =  new StringBuffer("");
    String line =  "";
    String newLine =  System.*getProperty*("line.separator");
    while ((line =  in.readLine()) ! =  null ) {
      sb.append(line  +  newLine);
    }
    in.close();

    Document doc =  null ;

    DocumentBuilderFactory dbf =  DocumentBuilderFactory.*newInstance*();

    DocumentBuilder db =  dbf.newDocumentBuilder();

    InputSource is =  new InputSource();
    is.setCharacterStream(new StringReader(sb.toString()));
    doc =  db.parse(is);

    NodeList nodes =  doc.getElementsByTagName("user");
    String[] names =  new String[nodes.getLength()];
    for (int k =  0; k  <  nodes.getLength(); ++k) {
      names[k] =  nodes.item(k).getAttributes().getNamedItem("name")
        .getNodeValue();
    }

    this .setListAdapter(new ArrayAdapter  < String  > (this ,
      R.layout.*list_item*, names));

    ListView lv =  getListView();
    lv.setTextFilterEnabled(true );

    lv.setOnItemClickListener(new OnItemClickListener() {
     public void onItemClick(AdapterView  < ?  >  parent, View view,
       int position,long id) {
        Toast.*makeText*(getApplicationContext(),
        ((TextView) view).getText(), Toast.*LENGTH_SHORT*)
        .show();
    }
    });

    }catch (IOException e) {
       Log.*e*("REST", "IOException "  +  e.getMessage());
    }catch (URISyntaxException e) {
       Log.*e*("REST", "Incorret URI Syntax "  +  e.getMessage());
    }catch (ParserConfigurationException e) {
       //TODO Auto-generated catch block
    e.printStackTrace();
    }catch (SAXException e) {
       //TODO Auto-generated catch block
       e.printStackTrace();
    }

   }
}

图 7-5 。带有 XML 响应的 RESTful API 查询的输出

对于 JSON 请求/响应代码和输出，分别看一下清单 7-5 和图 7-6 。

清单 7-5。 使用 RESTful API 获取数据并处理 JSON 输出

package net.zenconsult.android;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.app.ListActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

public class RESTJSONActivity extends ListActivity {
   @Override
   public void onCreate(Bundle savedInstanceState) {
    super .onCreate(savedInstanceState);
    BufferedReader in =  null ;
    try {
        HttpClient client =  new DefaultHttpClient();
        HttpGet request =  new HttpGet();
        request.setURI(new URI("http://192.168.3.105/apress/members.json"));
        HttpResponse response =  client.execute(request);
        in =  new BufferedReader(new InputStreamReader(response.getEntity()
        .getContent()));
        StringBuffer sb =  new StringBuffer("");
        String line =  "";
        while ((line =  in.readLine()) ! =  null ) {
           sb.append(line);
        }
        in.close();
        JSONObject users =  new JSONObject(sb.toString())
          .getJSONObject("users");
        JSONArray jArray =  users.getJSONArray("user");
        String[] names =  new String[jArray.length()];
        for (int i =  0; i  <  jArray.length(); i++) {
           JSONObject jsonObject =  jArray.getJSONObject(i);
           names[i] =  jsonObject.getString("name");
        }
    this .setListAdapter(new ArrayAdapter  < String  > (this ,
        R.layout.*list_item*, names));

      ListView lv =  getListView();
      lv.setTextFilterEnabled(true );
      lv.setOnItemClickListener(new OnItemClickListener() {
      public void onItemClick(AdapterView  < ?  >  parent, View view,
      int position,long id) {
         Toast.*makeText*(getApplicationContext(),
        ((TextView) view).getText(), Toast.*LENGTH_SHORT*)
        .show();
       }
     });
        }catch (IOException e) {
        Log.*e*("RESTJSON", "IOException "  +  e.getMessage());
        }catch (URISyntaxException e) {
        Log.*e*("RESTJSON", "Incorret URI Syntax "  +  e.getMessage());
        }catch (JSONException e) {
        //TODO Auto-generated catch block
        e.printStackTrace();
        }
   }
}

图 7-6 。带有 JSON 响应的 RESTful API 查询的输出

如果需要，可以将 XML 和 JSON 示例合并到一个类文件中。为了区分响应类型，通常可以在成员请求后附加一个文件扩展名。因此，对于 XML 响应，调用192 . 168 . 3 . 105/a press/members . XML； 并且，对于 JSON 响应，调用192 . 168 . 3 . 105/a press/members . JSON。同样，我们可以修改我们的示例，以便我们分析响应数据来自动发现结构。这将使我们能够根据某些关键字提取数据，而不管它们出现在哪里。然而，在大多数情况下，在代码中定义你的数据结构是无害的，因为毕竟，你的移动应用只会与你的移动中间件对话。

说到移动中间件，生成 XML 和 JSON 响应的服务器端代码到底在哪里？目前，这样的代码超出了本书的范围。但是为了让您更好地理解如何实现这种类型的移动中间件，请看附录中一个非常基本的例子，它也共享了部署说明。

摘要

如果让您开发一个与遗留企业系统一起工作的移动应用，我们快速地看了一下您将面临的两个问题。毫无疑问，当您涉足移动企业应用开发领域时，您可能会遇到不同的挑战。几乎在所有情况下，您都可以通过在移动中间件中构建翻译或桥接模块来克服这些问题。

就安全性而言，在本章的开始，我们讨论了向公众开放企业环境是一个坏主意。最好的方法是通过使用中间件来减少企业系统的暴露。我们决定使用 HTTP，不仅因为它的简单，还因为我们不需要做任何神奇的事情来保护它。可以应用与 SSL 相同的安全控制，而无需更改我们的任何代码。当然，我们也可以为我们的数据创建额外的加密和压缩层。

八、概念实战：第二部分

在这一章中，就像在第四章中一样，我们将更仔细地看看实现我们已经讨论过的一些理论概念的源代码和应用。这会让你对如何在实践中应用它们有更好的感觉。本章的代码示例将着重于设备上的安全认证和保护密码。回想一下，我们已经讨论了两种登录到后端应用而不在设备上存储凭证的机制。在这里，我们将探索与此相关的更详细的源代码。

oath〔??〕

让我们重温一下第六章中的 OAuth 登录示例。我们讨论了开发一个应用，该应用将与 Google Picasa 网络相册交互，以读取特定用户的相册列表。本章中的代码会做到这一点。查看这本书在 www.apress.comT3 的网站上的最新代码。首先，我们来看看图 8-1 中我们的项目结构。您将看到几个源文件。我们将讨论每个源文件的关键功能。

图 8-1 。OAuth 示例的项目结构

正在检索令牌

你可以在图 8-1 中看到 OAuth 示例项目的结构。让我们从应用的入口点开始，它是 OAuthPicasaActivity.java 的，如清单 8-1 所示。

清单 8-1。 申请入口点

**package** net.zenconsult.android;

**import** android.app.ListActivity;
**import** android.content.Intent;
**import** android.os.Bundle;
**import** android.view.View;
**import** android.widget.AdapterView;
**import** android.widget.AdapterView.OnItemClickListener;
**import** android.widget.ArrayAdapter;
**import** android.widget.ListView;
**import** android.widget.TextView;
**import** android.widget.Toast;

**public class** OAuthPicasaActivity **extends** ListActivity {
  OAuthPicasaActivity act;

  /** Called when the activity is first created. */
  @Override
  **public void** onCreate(Bundle savedInstanceState) {
         **super**.onCreate(savedInstanceState);
         act = **this;**
         OAuth o = **new** OAuth**(this)**;
         Token t = o.getToken();

  if (!t.isValidForReq()) {
          Intent intent = **new** Intent(**this**, AuthActivity.**class**);
          **this**.startActivity(intent);
         }
         **if** (t.isExpired()) {
                 o.getRequestToken();
         }

         DataFetcher df = **new** DataFetcher(t);
         df.fetchAlbums("sheranapress");
         String[] names = **new** String[] {}; // Add bridge code here to parse XML
                                           // from DataFetcher and populate
                                           // your List

         **this**.setListAdapter(**new** ArrayAdapter  < String > (**this**, R.layout.*list_item*,
                           names));

         ListView lv = getListView();
         lv.setTextFilterEnabled(**true**);

         lv.setOnItemClickListener(**new** OnItemClickListener() {
                 **public void** onItemClick(AdapterView  <?>  parent, View view,
                                 **int** position, **long** id) {
                            Toast.*makeText* (getApplicationContext(),
                                              ((TextView) view).getText(),
 Toast. *LENGTH_SHORT*).show();
            }
       });

  }

}

您将看到这个文件正在做几件事情。首先，它实例化了 OAuth 类。接下来，它检索令牌对象，并测试该令牌是否有效，以便在 isValidForReq() 函数中发出请求。它还在 isExpired() 函数中测试令牌是否过期。如果令牌有效，则实例化 DataFetcher 对象，该对象向 Picasa 查询属于用户 sheranapress 的所有相册列表。这是在 df . fetchalbums(" sherana press ")行中完成的。

显然，这个应用第一次运行时，不会有有效的令牌对象。应用处理这种情况的方法是，首先获取一个授权代码，然后获取一个带有该授权代码的请求令牌(按照 Google 的 OAuth 2 规范)。接下来看看这是怎么做的。

处理授权

清单 8-2 显示了我们的应用中处理授权部分的源代码。如果您查看 doAuth() 函数，您将看到一个对 Google 的请求，应用在一个 WebView 对象中显示响应。WebView 对象是一个显示 HTML 内容的字段。你可以把它想象成一个简约的浏览器。这允许最终用户登录到她的谷歌帐户，并授予或拒绝我们的应用访问。用户将看到 Google 登录网页，并被要求使用她的凭证登录。这些凭证没有存储在我们应用的任何地方。如果他允许我们的应用使用她的 Picasa 流，那么 Google 会发回一个授权码。我们的应用将把这个授权码存储在令牌对象中。这是在 ClientHandler 对象中完成的(参见清单 8-3 )。

清单 8-2。Auth 活动获取授权码。

**package** net.zenconsult.android;

**import** java.net.URI;
**import** java.net.URISyntaxException;

**import** org.apache.http.message.BasicNameValuePair;

**import** android.app.Activity;
**import** android.content.Context;
**import** android.os.Bundle;
**import** android.util.Log;
**import** android.webkit.WebView;

**public class** AuthActivity **extends** Activity {
        **private** BasicNameValuePair clientId = new BasicNameValuePair("client_id",
                         "200744748489.apps.googleusercontent.com");
        **private** BasicNameValuePair clientSecret = new BasicNameValuePair(
                         "client_secret", "edxCTl_L8_SFl1rz2klZ4DbB");
        **private** BasicNameValuePair redirectURI = new BasicNameValuePair(
                         "redirect_uri", "urn:ietf:wg:oauth:2.0:oob");
        **private** String scope = "scope=[`picasaweb.google.com/data/`](https://picasaweb.google.com/data/)";
        **private** String oAuth = "[`accounts.google.com/o/oauth2/auth`](https://accounts.google.com/o/oauth2/auth) ?";
        **private** String httpReqPost = " [`accounts.google.com/o/oauth2/token`](https://accounts.google.com/o/oauth2/token) ";
        **private final** String FILENAME = ".oauth_settings";
        **private** URI uri;
        **private** WebView wv;
        **private** Context ctx;
        **private** Token token;

        @Override
        **public void** onCreate(Bundle savedInstanceState) {
               **super**.onCreate(savedInstanceState);
               setContentView(R.layout.auth);
               doAuth();
  }
  **public void** doAuth() {
          **try** {
                 uri = **new** URI(oAuth + clientId + "&" + redirectURI + "&" + scope
                              + "&response_type = code");
                 wv = (WebView) findViewById(R.id.webview);
                 wv.setWebChromeClient(**new** ClientHandler(**this**));
                 wv.setWebViewClient(**new** MWebClient());
                 wv.getSettings().setJavaScriptEnabled(**true**);
                 wv.loadUrl(uri.toASCIIString());
                 Log.v("OAUTH", "Calling " + uri.toASCIIString());
          }**catch** (URISyntaxException e) {
                 e.printStackTrace();
          }
    }
}

清单 8-3。client handler 将授权码写入令牌对象。

package net.zenconsult.android;

import android.app.Activity;
import android.util.Log;

import android.webkit.WebChromeClient;
import android.webkit.WebView;
import android.widget.Toast;

public class ClientHandler extends WebChromeClient {
       private Activity activity;
       private OAuth oAuth;

       public ClientHandler(Activity act) {
               activity = act;
               oAuth = new OAuth(activity);
       }

       @Override
        public void onReceivedTitle(WebView view, String title) {
               String code = "";
               if (title.contains("Success")) {
                      code = title.substring(title.indexOf(' = ') + 1, title.length());
                      setAuthCode(code);
                      Log.v("OAUTH", "Code is " + code);
                      oAuth.getRequestToken();
                      oAuth.writeToken(oAuth.getToken());
                      Toast toast = Toast.makeText(activity.getApplicationContext(),
                                      "Authorization Successful", Toast.LENGTH_SHORT);
                      toast.show();
                      activity.finish();
               } else if (title.contains("Denied")) {
                      code = title.substring(title.indexOf(' = ') + 1, title.length());
                      setAuthCode(code);
                      Log.v("OAUTH", "Denied, error was " + code);
                      Toast toast = Toast.makeText(activity.getApplicationContext(),
                                      "Authorization Failed", Toast.LENGTH_SHORT);
                      toast.show();
                      activity.finish();
               }
         }

  public String getAuthCode() {
          return oAuth.getToken().getAuthCode();
  }

  public void setAuthCode(String authCode) {
          oAuth.getToken().setAuthCode(authCode);
  }

  @Override
  public void onProgressChanged(WebView view, int progress) {

  }
}

把 ClientHandler 想象成一个观察者。它在每个 HTML 网页中寻找一个特定的字符串——“成功”——。如果它找到了这个词，那么我们就获得了正确的授权码，这意味着我们的最终用户已经批准了我们的访问。

将授权码写入内部存储后，您将需要获取一个请求令牌。在 Oauth 中，您将需要一个请求令牌来开始请求访问任何资源的过程。OAuth 流程请参见图 6-25。如果您再次查看我们的 ClientHandler 代码，您将会看到下面几行代码 oAuth.getRequestToken() 和 oauth . write token(oauth . gettoken())。这两行使用实例化的 OAuth 类(参见清单 8-4 )请求一个请求令牌，然后将其写入内存。 getRequestToken() 函数处理该部分。同样值得注意的是，每当我提到存储时，您都应该考虑使用加密。有关实施安全数据存储的更多信息，请参考第五章中的“Android 中的数据存储”部分。

清单 8-4。 如果授权码有效，OAuth 类从 Google 获取请求令牌。

**package** net.zenconsult.android;

**import** java.io.BufferedInputStream;
**import** java.io.BufferedOutputStream;
**import** java.io.File;
**import** java.io.FileInputStream;
**import** java.io.FileNotFoundException;
**import** java.io.FileOutputStream;
**import** java.io.IOException;
**import** java.io.ObjectInputStream;
**import** java.io.ObjectOutputStream;
**import** java.io.StreamCorruptedException;
**import** java.io.UnsupportedEncodingException;
**import** java.net.URI;
**import** java.util.ArrayList;
**import** java.util.List;

**import** org.apache.http.HttpEntity;
**import** org.apache.http.HttpResponse;
**import** org.apache.http.NameValuePair;
**import** org.apache.http.client.ClientProtocolException;
**import** org.apache.http.client.HttpClient;
**import** org.apache.http.client.entity.UrlEncodedFormEntity;
**import** org.apache.http.client.methods.HttpPost;
**import** org.apache.http.impl.client.DefaultHttpClient;
**import** org.apache.http.message.BasicNameValuePair;
**import** org.apache.http.util.EntityUtils;
**import** org.json.JSONException;
**import** org.json.JSONObject;

**import** android.app.Activity;
**import** android.content.Context;
**import** android.util.Log;
**import** android.webkit.WebView;
**import** android.widget.Toast;

**public class** OAuth {
        **private** BasicNameValuePair clientId = **new** BasicNameValuePair("client_id",
                        "200744748489.apps.googleusercontent.com");
        **private** BasicNameValuePair clientSecret = **new** BasicNameValuePair(
                        "client_secret", "edxCTl_L8_SFl1rz2klZ4DbB");
        **private** BasicNameValuePair redirectURI = **new** BasicNameValuePair(
                        "redirect_uri", "urn:ietf:wg:oauth:2.0:oob");
        **private** String scope = "scope=[`picasaweb.google.com/data/`](https://picasaweb.google.com/data/)";
        **private** String oAuth = "[`accounts.google.com/o/oauth2/auth`](https://accounts.google.com/o/oauth2/auth)?";
        **private** String httpReqPost = "[`accounts.google.com/o/oauth2/token`](https://accounts.google.com/o/oauth2/token)";
        **private** final String FILENAME = ".oauth_settings";
        **private** URI uri;
        **private** WebView wv;
        **private** Context ctx;
        **private** Activity activity;
        **private boolean** authenticated;
        **private** Token token;

        **public** OAuth(Activity act) {
                ctx = act.getApplicationContext();
                activity = act;
                token = readToken();

        }

        **public** Token readToken() {
                Token token = **null**;
                FileInputStream fis;
                **try** {
                        fis = ctx.openFileInput(FILENAME);
                        ObjectInputStream in = **new** ObjectInputStream(
                                       **new** BufferedInputStream(fis));
                        token = (Token) in.readObject();
                        **if** (token == **null**) {
                                token = **new** Token();
                                writeToken(token);
                        } 
                        in.close();
                        fis.close();
                } **catch** (FileNotFoundException e) {
                        writeToken(**new** Token());
                } **catch** (StreamCorruptedException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                } **catch** (IOException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                } **catch** (ClassNotFoundException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                }
                **return** token;
                }

        **public void** writeToken(Token token) {
                **try** {
                        File f = **new** File(FILENAME);
                        **if** (f.exists()) {
                                f.delete();
                        }
                        FileOutputStream fos = ctx.openFileOutput(FILENAME,
                                       Context.*MODE_PRIVATE*);

                        ObjectOutputStream out = **new** ObjectOutputStream(
                                       **new** BufferedOutputStream(fos));
                        out.writeObject(token);
                        out.close();
                        fos.close();
                } **catch** (FileNotFoundException e1) {
                        Log.*e*("OAUTH", "Error creating settings file");
                } **catch** (IOException e2) {
                        // **TODO** Auto-generated catch block
                        e2.printStackTrace();
                }
        }

        **public void** getRequestToken() {
                HttpClient httpClient = **new** DefaultHttpClient();
                HttpPost post = **new** HttpPost(httpReqPost);
                List  <  NameValuePair  > nvPairs = **new** ArrayList  <  NameValuePair  >  ();
                nvPairs.add(clientId);
                nvPairs.add(clientSecret);
                nvPairs.add(**new** BasicNameValuePair("code", token.getAuthCode()));
                nvPairs.add(redirectURI);
                nvPairs.add(**new** BasicNameValuePair("grant_type", "authorization_code"));
                **try** {
                        post.setEntity(**new** UrlEncodedFormEntity(nvPairs));
                        HttpResponse response = httpClient.execute(post);
                        HttpEntity httpEntity = response.getEntity();
                        String line = EntityUtils.*toString*(httpEntity);
                        JSONObject jObj = **new** JSONObject(line);
                        token.buildToken(jObj);
                        writeToken(token);
                } **catch** (UnsupportedEncodingException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                } **catch** (ClientProtocolException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                } **catch** (IOException e) {
                        **if** (e.getMessage().equals("No peer certificate")) {
                                Toast toast = Toast.*makeText*![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
(activity.getApplicationContext(),
                                                "Possible HTC Error for Android 2.3.3",
                                                Toast.*LENGTH_SHORT*);
                            toast.show();
                        }
                        Log.*e*("OAUTH", "IOException " + e.getMessage());
                } **catch** (JSONException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                }

        }

        **public** Token getToken() {
                **return** token;
        }

        **public void** setToken(Token token) {
                **this**.token = token;
        }
}

您可能已经注意到，该令牌被用作单例令牌。它被写入设备的内部存储器并从中读取。这允许应用的不同区域在身份验证过程的不同阶段对其进行读写。理想情况下，这应该是同步的，以确保读和写只发生在一个类中。

我已经为清单 8-5 中的令牌对象提供了源代码。该对象实现了可序列化的接口；因此，它可以完整地写入内部存储。确保通过数据存储加密器运行它，以增加安全性。除了检查自己的到期日期之外，令牌对象几乎不包含任何逻辑。

清单 8-5。 令牌对象

package net.zenconsult.android;

**import** java.io.Serializable;
**import** java.util.Calendar;
**import** org.json.JSONException;
**import** org.json.JSONObject;
**public class** Token **implements** Serializable {
        /**
        *
        */
        **private static final long** serialVersionUID = 6534067628631656760L;
        **private** String refreshToken;
        **private**  String accessToken;
        **private**  Calendar expiryDate;
        **private**  String authCode;
        **private**  String tokenType;
        **private**  String name;

        **public** Token() {
                setExpiryDate(0);
                setTokenType("");
                setAccessToken("");
                setRefreshToken("");
                setName("");
        }

        **public** Token(JSONObject response) {
                try {
                      setExpiryDate(response.getInt("expires_in"));
                } **catch** (JSONException e) {
                      setExpiryDate(0);
                }
                try {
                      setTokenType(response.getString("token_type"));
                } **catch** (JSONException e) {
                      setTokenType("");
                }
                try {
                      setAccessToken(response.getString("access_token"));
                } **catch** (JSONException e) {
                      setAccessToken("");
                }
                try {
                      setRefreshToken(response.getString("refresh_token"));
                } **catch** (JSONException e) {
                      setRefreshToken("");
                }
        }
        **public void** buildToken(JSONObject response) {
                try {
                      setExpiryDate(response.getInt("expires_in"));
                } catch (JSONException e) {
                      setExpiryDate(0);
                }
                try {
                      setTokenType(response.getString("token_type"));
                } catch (JSONException e) {
                      setTokenType("");
                }
                try {
                      setAccessToken(response.getString("access_token"));
                } catch (JSONException e) {
                      setAccessToken("");
                }
                try {
                      setRefreshToken(response.getString("refresh_token"));
                } catch (JSONException e) {
                      setRefreshToken("");
                }
        }

        **public boolean** isValidForReq() {
                if (getAccessToken() != null && !getAccessToken().equals("")) {
                      return true;
                } else {
                      return false;
                }
        }

        **public boolean**  isExpired() {
                Calendar now = Calendar.getInstance();
                if (now.after(getExpiryDate()))
                      return true;
                else
                      return false;
        }

        **public** String getRefreshToken() {
                      return refreshToken;
        }

        **public void** setRefreshToken(String refreshToken) {
                if (refreshToken == null)
                        refreshToken = "";
                        this.refreshToken = refreshToken;
        }

        **public** String getAccessToken() {
                      return accessToken;
        }

        **public void** setAccessToken(String accessToken) {
                if (accessToken == null)
                        accessToken = "";
                this.accessToken = accessToken;
        }

        **public** Calendar getExpiryDate() {
                      return expiryDate;
        }

        **public void** setExpiryDate(int seconds) {
                Calendar now = Calendar.getInstance();
                now.add(Calendar.SECOND, seconds);
                this.expiryDate = now;
        }

        **public** String getAuthCode() {
                      return authCode;
        }

        **public void** setAuthCode(String authCode) {
                if (authCode == null)
                authCode = "";
                this.authCode = authCode;
        }

        **public** String getTokenType() {
                      return tokenType;
        }

        **public void** setTokenType(String tokenType) {
                if (tokenType == null)
                tokenType = "";
                this.tokenType = tokenType;
        }

        **public** String getName() {
                      return name;
        }

        **public void** setName(String name) {
                this.name = name;
        }
}

最后，还有数据提取器类(见清单 8-6 )。您使用该类对 Picasa 进行所有受保护的查询。例如，您可以使用这个类来获取相册和照片，甚至上传照片。Picasa 以 XML 格式发回所有回复(注意，我省略了 XML 解析组件)。如果你想知道如何编写一个简单的 XML 解析器来读取 Picasa 的响应，那么看看这本书的附录。

清单 8-6。data etcher 类

**package** net.zenconsult.android;

**import** java.io.IOException;

**import** org.apache.http.HttpEntity;
**import** org.apache.http.HttpResponse;
**import** org.apache.http.client.ClientProtocolException;
**import** org.apache.http.client.HttpClient;
**import** org.apache.http.client.methods.HttpGet;
**import** org.apache.http.impl.client.DefaultHttpClient;
**import** org.apache.http.util.EntityUtils;

**public** class DataFetcher {
        **private** HttpClient httpClient;

        **private** Token token;
        **public** DataFetcher(Token t) {
                token = t;
                httpClient = **new** DefaultHttpClient();
        }
        **public void** fetchAlbums(String userId) {
                String url = " [`picasaweb.google.com/data/feed/api/user/`](https://picasaweb.google.com/data/feed/api/user/) "
                                  + userId;
                **try** {
                     HttpResponse resp = httpClient.execute(buildGet(
                                   token.getAccessToken(), url));
                     **if** (resp.getStatusLine().getStatusCode() == 200) {
                                          HttpEntity httpEntity = resp.getEntity();
                                          String line = EntityUtils. *toString*(httpEntity);
                                          // Do your XML Parsing here
                                          }
                } **catch** (ClientProtocolException e) {
                                          // TODO Auto-generated **catch** block
                                          e.printStackTrace();
                } **catch** (IOException e) {
                                          // TODO Auto-generated **catch** block
                                          e.printStackTrace();
        }
        }
        **public** HttpGet buildGet(String accessToken, String url) {
                HttpGet get = **new** HttpGet(url);
                get.addHeader("Authorization", "Bearer " + accessToken);
                return get;
        }
}

挑战响应

我们在第六章的中非常简要地讨论了基于挑战响应的认证。让我们仔细看看挑战-响应认证技术。以下是所需步骤 ?? 的简要概述，也显示在图 8-2 中。请记住，这只是服务器对客户端进行身份验证的单向身份验证:1。

1. 客户端请求安全资源。
2. 服务器发送一个质询字符串 c。
3. 客户端生成一个随机字符串 r。
4. 客户端根据 C、R 和用户密码生成一个散列。
5. 客户端将 R 和散列发送回服务器。
6. 服务器根据存储的用户密码和。
7. 如果验证正确，服务器发回请求的资源；否则，会发回一条错误消息。

图 8-2 。质询-响应会话期间客户端和服务器之间数据交换的图形表示

注意您还可以有一个相互认证的场景，其中客户端对服务器进行认证。

让我们编写一些简单的代码，帮助我们在应用中使用挑战-响应认证技术。您应该发展这些代码段以适应您自己的需要，然后在您的应用中使用它们。它们有助于减少终端用户的暴露，因为您不会在设备上存储任何凭据。我已经给出了客户端和服务器端代码的例子。服务器端的代码是用 Java 写的，可以打包成 Java Web 存档文件(WAR 文件)。要测试它，将它打包成一个 WAR 文件，并简单地将它放到 servlet 容器或应用服务器的部署目录中。

让我们从服务器端代码开始。我们将创建一个 Java servlet 来处理与客户端的 HTTP 通信。图 8-3 显示了项目结构。这个结构说明了我们有一个只有四个文件的相当简单的项目。

图 8-3 。我们的挑战响应服务器端项目结构

其中之一，Hex.java 文件 ，是我用来将各种数据类型转换成十六进制字符串的工具类；另一个，【Constants.java】，保存用户名和密码。这些凭证将用于比较客户端输入的内容。

您还会注意到，我们使用 Apache Commons 编解码器库来帮助我们的 Base64 编码和解码。在本例中，我们采用 CRAM-MD5 身份验证方法，改为使用 SHA1 哈希。(CRAM 是挑战响应认证机制。)

我将首先展示代码，然后解释我们要做什么。让我们从我们的 servletLogin.java 开始，如清单 8-7 所示。该代码有两个主要分支:

• 主分支 1 处理接收到没有“挑战”参数的请求的情况。
• 主分支 2 处理接收到带有“挑战”参数的请求的情况。

清单 8-7。 登录类

**package** net.zenconsult.android;

**import** java.io.IOException;

**import** javax.servlet.ServletException;
**import** javax.servlet.annotation.WebServlet;
**import** javax.servlet.http.HttpServlet;
**import** javax.servlet.http.HttpServletRequest;
**import** javax.servlet.http.HttpServletResponse;
**import** javax.servlet.http.HttpSession;

/**
        * Servlet implementation class login
        */
@WebServlet(description = "Login Servlet", urlPatterns = { "/login" })
        **public class** Login **extends** HttpServlet {
                **private static final long** serialVersionUID = 1 L;

        /**
                * **@see** HttpServlet#HttpServlet()
                */
                **public** Login() {
                **super()**;
                **// TODO** Auto-generated constructor stub
                }

                /**
                * **@see** HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
                * response)
                */
        **protected void** doGet(HttpServletRequest request,
                        HttpServletResponse response) **throws** ServletException,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
  IOException {
                HttpSession session = request.getSession();
                String param = request.getParameter("challenge");
                **if** (param != **null**) {
                CRAM c = (CRAM) session.getAttribute("challenge");
                **if** (c == **null**) {
                c = **new** CRAM();
                session.setAttribute("challenge", c);
                response.setHeader("Content-Type", "text/xml");
                response.getWriter().write(c.generate());
                } **else** {
                **if** (c.verifyChallenge(param.trim())) {
                response.setHeader("Content-Type", "text/xml");
                response.getWriter().write![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
(c.generateReply("Authorized"));
                session.invalidate();
                } **else** {
                response.setHeader("Content-Type", "text/xml");
                response.getWriter().write![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
(c.generateReply("Unauthorized"));
                session.invalidate();
                }
                }
                } **else** {
                CRAM c = **new** CRAM();
                session.setAttribute("challenge", c);
                response.setHeader("Content-Type", "text/xml");
                response.getWriter().write(c.generate());
                }

                }

                /**
                * **@see** HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
                * response)
                */
                **protected void** doPost(HttpServletRequest request,
                HttpServletResponse response) **throws** ServletException,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
                IOException {
                **// TODO** Auto-generated method stub
                }
}

在每种情况下，我们都在创建一个 CRAM 对象。该对象将生成我们的质询字符串，并对用户响应进行比较。我们将 CRAM 对象与每个 HTTP 会话相关联，以便使用相同的挑战字节进行验证。

现在将是一个很好的时间来从协议层面看一下客户端和服务器之间发生了什么(见图 8-4 )。整个流程有四个步骤，非常简单:

1. 客户端请求受保护的资源。
2. 服务器回复一个询问。
3. 客户端使用最终用户凭证来计算响应，并将其发送回服务器。
4. 最后，服务器将计算相同的响应，进行比较，并决定用户是否被授权。

图 8-4 。挑战响应消息流

所有这些都是在不通过 Web 发送用户凭证的情况下完成的。

CRAM 对象 的源代码如清单 8-8 所示。

清单 8-8。 补习班

**package** net.zenconsult.android;

**import** java.io.StringWriter;
**import** java.security.InvalidKeyException;
**import** java.security.NoSuchAlgorithmException;
**import** java.security.SecureRandom;
**import** javax.crypto.Mac;

**import** javax.crypto.SecretKey;
**import** javax.crypto.spec.SecretKeySpec;
**import** javax.xml.parsers.DocumentBuilder;
**import** javax.xml.parsers.DocumentBuilderFactory;
**import** javax.xml.parsers.ParserConfigurationException;
**import** javax.xml.transform.OutputKeys;
**import** javax.xml.transform.Transformer;
**import** javax.xml.transform.TransformerConfigurationException;
**import** javax.xml.transform.TransformerException;
**import** javax.xml.transform.TransformerFactory;
**import** javax.xml.transform.dom.DOMSource;
**import** javax.xml.transform.stream.StreamResult;

**import** org.apache.commons.codec.binary.Base64;
**import** org.w3c.dom.Document;
**import** org.w3c.dom.Element;
**import** org.w3c.dom.Text;

**public class** CRAM **implements** Constants {
  **private final byte[]** secret = **new byte[32];**

         **public** CRAM() {
                 SecureRandom sr = **new** SecureRandom();
                 sr.nextBytes(secret);
                 }

         **public** String generate() {
                 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.*newInstance*();
                 DocumentBuilder dBuilder = **null**;
                 try {
                       dBuilder = dbFactory.newDocumentBuilder();
                 } **catch** (ParserConfigurationException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 Document doc = dBuilder.newDocument();

                 // Build Root
                 Element root = doc.createElement("ServerResponse");
                 doc.appendChild(root);

                 // Challenge Section
                 Element authChallenge = doc.createElement("AuthChallenge");
                 root.appendChild(authChallenge);

                 // The Challenge
                 Element challenge = doc.createElement("Challenge");
                 Text challengeText = doc.createTextNode(Base64
                               .*encodeBase64String*(secret));
                 challenge.appendChild(challengeText);
                 authChallenge.appendChild(challenge);

                 TransformerFactory tFactory = TransformerFactory.*newInstance*();
                 Transformer transformer = **null**;
                 **try** {
                       transformer = tFactory.newTransformer();
                 } **catch** (TransformerConfigurationException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 transformer.setOutputProperty(OutputKeys.*OMIT_XML_DECLARATION*, "yes");
                 transformer.setOutputProperty(OutputKeys.*INDENT*, "yes");
                 StringWriter sw = **new** StringWriter();
                 StreamResult res = **new** StreamResult(sw);
                 DOMSource source = **new** DOMSource(doc);
                 **try** {
                       transformer.transform(source, res);
                 } **catch** (TransformerException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 String xml = sw.toString();
                 **return** xml;
                 }
         **public boolean** verifyChallenge(String userResponse) {
                 String algo = "HmacSHA1";
                 Mac mac = **null**;
                 **try** {
                        mac = Mac.*getInstance*(algo);
                 } **catch** (NoSuchAlgorithmException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 SecretKey key = **new** SecretKeySpec(*PASSWORD*.getBytes(), algo);

                 **try** {
                 mac.init(key);
                 } **catch** (InvalidKeyException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 String tmpHash = *USERNAME* + " " + Hex.*toHex*(mac.doFinal(secret));
                 String hash = Base64.*encodeBase64String*(tmpHash.getBytes());
                 **return** hash.equals(userResponse);
                 }

                 public String generateReply(String response) {
                 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.*newInstance*();
                 DocumentBuilder dBuilder = **null**;
                 **try** {
                 dBuilder = dbFactory.newDocumentBuilder();
                 } **catch** (ParserConfigurationException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 Document doc = dBuilder.newDocument();

                 // Build Root
                 Element root = doc.createElement("ServerResponse");
                 doc.appendChild(root);

                 // Challenge Section
                 Element authChallenge = doc.createElement("AuthChallenge");
                 root.appendChild(authChallenge);

                 // Reply
                 Element challenge = doc.createElement("Response");
                 Text challengeText = doc.createTextNode(response);
                 challenge.appendChild(challengeText);
                 authChallenge.appendChild(challenge);

                 TransformerFactory tFactory = TransformerFactory.*newInstance*();
                 Transformer transformer = **null**;
                 **try** {
                 transformer = tFactory.newTransformer();
                 } **catch** (TransformerConfigurationException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 transformer.setOutputProperty(OutputKeys.*OMIT_XML_DECLARATION*, "yes");
                 transformer.setOutputProperty(OutputKeys.*INDENT*, "yes");
                 StringWriter sw = **new** StringWriter();
                 StreamResult res = **new** StreamResult(sw);
                 DOMSource source = **new** DOMSource(doc);
                 **try** {
                 transformer.transform(source, res);
                 } **catch** (TransformerException e) {
                       // **TODO** Auto-generated catch block
                       e.printStackTrace();
                 }
                 String xml = sw.toString();
                 **return** xml;
         }

}

在实例化 CRAM 对象时，生成一个新的 32 字节随机数。这是一个领域，而且它与补习对象密切相关。这个随机字节串将用于进一步的质询生成和响应验证。

接下来是 generate() 函数 ，它只不过是为我们生成的随机字节创建一个 Base64 编码。然后，它创建一个 XML 响应和这个质询字符串，然后将它返回给 servlet，以便发送给最终用户。

下一个函数 verify challenge(String user response)是一个重要的函数。如果使用了正确的凭据，它将生成客户端应该生成的响应。使用存储的用户密码，通过 HMAC-SHA1 算法对原始随机字节序列进行哈希运算。然后用户名被添加到这个散列的前面，并进行 Base64 编码。接下来，将它与客户端响应进行比较，当然，如果用户名和密码输入正确，客户端响应应该是相同的 — 。

最后，generate reply(String response)函数将把响应变量中指定的单词作为 XML 文本发回。servlet 根据客户端响应 是否正确，使用以下任意一个词调用该函数:

• 【授权】
• “未授权”

您还可以设置一个特殊的授权 cookie 来表明会话已经过身份验证。有许多方法可以改进和构建这些代码。我在这里包含了基本代码，这样您可以更好地理解如何在您的前端和后端应用中实现挑战-响应身份验证机制。

现在我们已经看了服务器端代码 ，让我们为客户端写一些代码。我已经在图 8-5 中展示了项目结构。同样，skeletal 项目相当简单，只有三个文件，不包括十六进制函数类。我将带你浏览每个文件的功能，从入口点开始，【ChallengeResponseClientActivity.java】的(见清单 8-9 )。创建一个 Comms 对象(参见清单 8-10 )和一个 CRAM 对象(参见清单 8-11 )的代码相当简单。 Comms 对象处理客户端和服务器之间的所有网络通信，而 CRAM 对象处理哈希生成部分。在服务器端， CRAM 对象与 CRAM 对象非常相似。在这种情况下，没有验证组件，因为客户端不验证服务器。相反， CRAM 对象使用 HMAC-SHA1 来计算基于服务器挑战的散列。

清单 8-9。 切入点和主要活动

**package** net.zenconsult.android;

**import** android.app.Activity;
**import** android.os.Bundle;
**import** android.view.View;
**import** android.widget.Button;
**import** android.widget.Toast;

**public class** ChallengeResponseClientActivity **extends** Activity {
         /** Called when the activity is first created. */
         @Override
         **public void** onCreate(Bundle savedInstanceState) {
                 **super**.onCreate(savedInstanceState);
                 setContentView(R.layout. *main*); 
                 **final** Activity activity = **this;**

                 **final** Button button = (Button) findViewById(R.id.*button1*);
                 button.setOnClickListener(new View.OnClickListener() {
                         **public void** onClick(View v) {
                                 Comms c = new Comms(activity);
                                        String challenge = c.getChallenge();
                                        CRAM cram = new CRAM(activity);
                                        String hash = cram.generate(challenge);
                                        String reply = c.sendResponse(hash);
                                        **if** (c.authorized(reply)) {
                                                 Toast toast = Toast.*makeText*(
                                                         activity![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
.getApplicationContext(), "Login success",
         Toast.*LENGTH_LONG*);
                                            toast.show();
                                        } **else** {
                                                 Toast toast = Toast.*makeText*(
                                                         activity![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
.getApplicationContext(), "Login failed",
         Toast.*LENGTH_LONG*);
                                                 toast.show();
                                        }
                             }
                 });
         }
}

清单 8-10。Comms 类处理这个应用的所有 HTTP 请求。

package net.zenconsult.android;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import android.app.Activity;
import android.content.Context;
import android.util.Log;
import android.widget.Toast;

public class Comms {
  private final String url = "[`192.168.3.117:8080/ChallengeResponse/login`](http://192.168.3.117:8080/ChallengeResponse/login)";
  private Context ctx;
  private DefaultHttpClient client;

  public Comms(Activity act) {
  ctx = act.getApplicationContext();
  client = new DefaultHttpClient();
  }

  public String sendResponse(String hash) {
  List  <  NameValuePair  >  params = new ArrayList  <  NameValuePair  >  ();
  params.add(new BasicNameValuePair("challenge", hash));
  String paramString = URLEncodedUtils.*format*(params, "utf-8");
  String cUrl = url + "?" + paramString;
  return doGetAsString(cUrl);
  }

  public boolean authorized(String response) {
  InputStream is = new ByteArrayInputStream(response.getBytes());
  DocumentBuilderFactory dbFactory = DocumentBuilderFactory.*newInstance*();
  DocumentBuilder db = null;
  Document doc = null;
  String reply = "";
  try {
  db = dbFactory.newDocumentBuilder();
  doc = db.parse(is);
  NodeList nl = doc.getElementsByTagName("Response");
  reply = nl.item(0).getTextContent();
  is.close();
  } catch (ParserConfigurationException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  } catch (SAXException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  } catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  }
  return reply.matches("Authorized");
  }

  public String getChallenge() {
  InputStream challengeText = doGetAsInputStream(url);
  DocumentBuilderFactory dbFactory = DocumentBuilderFactory.*newInstance*();
  DocumentBuilder db = null;
  Document doc = null;
  String challenge = "";
  try {
  db = dbFactory.newDocumentBuilder();
  doc = db.parse(challengeText);
  NodeList nl = doc.getElementsByTagName("Challenge");
  challenge = nl.item(0).getTextContent();
  challengeText.close();
  } catch (SAXException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  } catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  } catch (ParserConfigurationException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  }
  return challenge;
  }

  public String doGetAsString(String url) {
  HttpGet request = new HttpGet(url);
  String result = "";
  try {
  HttpResponse response = client.execute(request);
  int code = response.getStatusLine().getStatusCode();
  if (code == 200) {
  result = EntityUtils.*toString*(response.getEntity());
  } else {
  Toast toast = Toast.*makeText*(ctx, "Status Code " + code,
  Toast.*LENGTH_SHORT*);
  toast.show();
  }
  } catch (ClientProtocolException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  } catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  }
  return result;

  }

  public InputStream doGetAsInputStream(String url) {
  HttpGet request = new HttpGet(url);
  InputStream result = null;
  try {
  HttpResponse response = client.execute(request);
  int code = response.getStatusLine().getStatusCode();
  if (code == 200) {
  result = response.getEntity().getContent();
  } else {
  Toast toast = Toast.*makeText*(ctx, "Status Code " + code,
  Toast.*LENGTH_SHORT*);
  toast.show();
  }
  } catch (ClientProtocolException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  } catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  }
  return result;

  }
}

清单 8-11。 补习班

**package** net.zenconsult.android;

**import** java.security.InvalidKeyException;
**import** java.security.NoSuchAlgorithmException;

**import** javax.crypto.Mac;
**import** javax.crypto.SecretKey;
**import** javax.crypto.spec.SecretKeySpec;

**import** android.app.Activity;
**import** android.util.Base64;
**import** android.widget.TextView;

 **public class** CRAM {
        **private Activity** activity;

        **public** CRAM(Activity act) {
                 activity = act;
  }

        **public** String generate(String serverChallenge) {
                String algo = "HmacSHA1";
                TextView pass = (TextView) activity.findViewById(R.id.*editText2*);
                **byte[]** server = Base64.*decode*(serverChallenge, Base64.*DEFAULT*);

                Mac mac = null;
                **try** {
                        mac = Mac.*getInstance*(algo);
                } **catch** (NoSuchAlgorithmException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                }
                String keyText = pass.getText().toString();
                SecretKey key = **new** SecretKeySpec(keyText.getBytes(), algo);
                **try** {
                        mac.init(key);
                } **catch** (InvalidKeyException e) {
                        // **TODO** Auto-generated catch block
                        e.printStackTrace();
                }
                **byte[]** tmpHash = mac.doFinal(server);
                TextView user = (TextView) activity.findViewById(R.id.*editText1*);
                String username = user.getText().toString();
                String concat = username + " " + Hex.*toHex*(tmpHash);
                String hash = Base64.*encodeToString*(concat.getBytes(), Base64.*URL_SAFE*);
                **return** hash;
        }
}

在客户端 ，如果一切按计划进行，你的 app 会弹出一条精彩的“登录成功”的消息来迎接你，如图图 8-5 所示。

图 8-5 成功的挑战-响应身份验证

摘要

我希望这些例子能让您更好地理解如何在移动和后端 web 应用中实现替代的身份验证机制。通过减少对用户凭据存储的依赖，您可以显著提高应用的安全性。

在前端和后端代码中实现 OAuth 不会是最容易完成的事情。然而，花费一些初始努力并为将来的代码准备一组可重用的库是值得的。补习也是一样。由于所涉及的工作量，这些身份验证方法并不是许多开发人员首先要考虑的。但是，它可以确保您的应用比那些通过网络存储和转发用户凭据的应用更安全。

希望你会认为你到目前为止学到的东西是有用的。我的希望是，你会相信你没有浪费时间在这个新协议的缩写上，它被称为挑战响应认证协议。

九、发布和销售您的应用

你可能决定通过出售你花了无数时间开发的应用来赚钱。随着移动领域最近的发展，个人开发者现在比以往任何时候都更容易营销、销售其应用并从中赚取收入。苹果有 iTunes 应用商店，黑莓有 AppWorld，安卓有市场。销售应用的过程很简单:注册成为应用销售者，然后在在线商店上发布你的应用。一旦获得批准，您的应用将立即可供 Android 用户下载。在这一章中，我们将更详细地研究这个过程，我将讲述如何让你的应用在 Android Market 上上市的基础知识。在这个过程中，我会谈到从你决定你的应用运行良好开始，到你决定把它发布到网上为止，都涉及到哪些步骤。当谈到在线销售你的应用时，我还会谈到另一个要点:收入保护。如果你的应用在任何在线商店变得受欢迎，那么你很可能会吸引那些想要“破解”和盗版你的应用的人。除非你打算免费发布你的应用，否则这可能会影响你的收入。我将花一些时间在这个主题上，并探索如何编写好的许可证密钥和注册例程来阻止盗版。在这一节中，我还将阐明如果你的应用发现自己处于一个敌对的环境中，它可能不得不经历的一些事情。

开发者注册

你还记得我们之前写的 Proxim 应用吗？让我们在 Android 市场上免费发布。我将带您了解发布应用的基础知识。在这种情况下，我不会输入任何允许我收款的具体财务信息(例如，我的银行账号)，因为我不打算出售该应用。此外，我不想花太多时间告诉你如何注册成为一名开发人员，因为谷歌已经有很多关于这方面的有用信息和一套关于如何开始的综合文章。

在发布你的应用之前，你需要做的第一件事就是注册成为一名开发者。您可以使用现有的 Gmail 帐户进行注册。导航到 http://market.android.com/publish 的 并登录(参见图 9-1 )。在本文发表时，注册开发者的费用是 25 美元。你通过 Google Checkout 支付这个金额，而且是一次性的注册费用(见图 9-2 )。费用的存在是为了确保你是一个认真的开发者。据谷歌称，这有助于减少可能进入市场的“垃圾产品”的数量。

图 9-1 注册发布您的应用

图 9-2 注册费的支付

您的应用——已公开

外面是一片丛林。谁知道你的应用最终会在哪里？嗯，这大概是夸张了；但是正如我在这一章开始时提到的，任何可以访问 Android Market 的人都可以下载你的应用。如果这些下载转化为收入，那就太好了；不幸的是，在某些情况下，盗版会让你损失收入。盗版不是什么新鲜事。自从桌面计算时代开始，它就存在了。盗版的正式术语是侵犯软件版权；它意味着在没有适当授权的情况下将一个软件从一个设备复制到另一个设备。在大多数情况下，这仅仅意味着复制你没有购买和支付的软件。如果一个朋友买了一些软件，并给了你一份你没有付钱的拷贝，那么你就拥有了你没有购买的软件。在成长的过程中，我记得我是如何迫不及待地走进我买第一台 8088 电脑的商店(一个巨大的笨重的、坚不可摧的金属怪兽),把我每周的零花钱花在最新的游戏上。当时，我从未想过我参与了协助盗版。据我所知，我付了现金，收到了一个游戏作为回报。我从来没有意识到我支付的是从原始开发者那里购买软件的十分之一。我也不知道我的钱从来没有到达最初的开发商；它留在了店里。

开发者仍然会因为软件盗版而损失收入。你的软件有多受欢迎，以及你如何分发它，将在你的软件被盗版的程度中起到关键作用。例如，如果你允许在七天内免费试用你的应用，但允许完全访问它的所有功能，那么很可能有人会试图绕过这七天的试用期。如果成功了，那么这个人就不需要付费下载你的应用的完整版本了。侵犯版权的另一种隐蔽形式是代码盗窃。当有人下载你的软件，对其进行逆向工程，并复制代码时，就会发生这种情况。然后，这个人将你的代码重新包装成新产品，并以较低的价格出售。证明这种侵犯版权的唯一方法是下载新的和类似的应用，对其进行逆向工程，并寻找与你自己相同的编码结构。但是，如果代码被修改，这将是一项艰巨的任务来证明，甚至更难在法庭上打，因为涉及的成本很高。作为一个个人开发者，你可能不会有太多的资源用于打击盗版。因此，最好决定你是否想要保护你的应用免受盗版 — 的侵害，如果是的话，如何保护。

在这一部分，我将讨论一些你在做决定时需要考虑的话题。然后，如果你确信你需要保护你的应用免受盗版，我会给你一些例子，告诉你如何使用 Android 的许可证验证库(LVL) 来阻止未来的盗版者非法复制和分发你的应用。让我们从你的应用放在 Android Market 上时会发生什么开始。

可供下载

当你的应用出现在 Android 市场时，最终用户可以下载它。如果你对应用收费，那么显然最终用户在下载之前必须先购买它。一旦应用安装到设备上，你就可以使用 Android 调试桥(adb)将其复制到电脑上。adb 允许您以不同的方式与您的 Android 设备进行交互。您可以安装软件，打开 Linux shell 以浏览设备文件系统，以及将文件复制到设备或从设备复制文件。我已经在清单 9-1 中给出了 adb 特性的完整列表。你可以在你的 Android SDK 的平台-工具目录下找到 adb。对我来说，这个位置是在/Users/sheran/Android-SDK-MAC _ x86/platform-tools。

清单 9-1 。 亚行命令及功能

Android Debug Bridge version 1.0.29

 -d - directs command to the only connected USB device
  returns an error if more than one USB device is![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 present.
 -e - directs command to the only running emulator.
  returns an error if more than one emulator is running.
 -s  <  serial number> - directs command to the USB device or emulator with
  the given serial number. Overrides ANDROID_SERIAL
  environment variable.
 -p  <  product name or path> - simple product name like 'sooner', or
  a relative/absolute path to a product
  out directory like 'out/target/product/sooner'.
  If -p is not specified, the ANDROID_PRODUCT_OUT
  environment variable is used, which must
  be an absolute path.
 devices    - list all connected devices
 connect  <  host  >  [:<port>]    - connect to a device via TCP/IP
  Port 5555 is used by default if no port number is![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 specified.
 disconnect [<host  >  [:<port>]] - disconnect from a TCP/IP device.
  Port 5555 is used by default if no port number is![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 specified.
  Using this command with no additional arguments
  will disconnect from all connected TCP/IP devices.

device commands:
  adb push  <  local  >  <remote>    -      copy file/dir to device
  adb pull  <  remote  >  [<local>]    -      copy file/dir from device
  adb sync [ <directory> ]    - copy host-  >  device only if changed
  (−l means list but don't copy)
  (see 'adb help all')
  adb shell    - run remote shell interactively
  adb shell  <  command> - run remote shell command
  adb emu  <  command> - run emulator console command
  adb logcat [ <filter-spec> ]    - View device log
  adb forward  <  local  >  <remote  >   − forward socket connections
     forward specs are one of:
  tcp:<port>
  localabstract:<unix domain socket name>
  localreserved:<unix domain socket name>
  localfilesystem:<unix domain socket name>
  dev:<character device name>
  jdwp:<process pid  >  (remote only)
  adb jdwp    - list PIDs of processes hosting a JDWP transport
  adb install [−l] [−r] [−s]  <  file  >  − push this package file to the device and install![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 it
  ('-l' means forward-lock the app)
  ('-r' means reinstall the app, keeping its data)
  ('-s' means install on SD card instead of internal![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 storage)
  adb uninstall [−k]  <  package  >  − remove this app package from the device
  ('-k' means keep the data and cache directories)
  adb bugreport    -     return all information from the device
  that should be included in a bug report.

  adb backup [−f  <  file>] [−apk|-noapk] [−shared|-noshared] [−all] [−system|-nosystem]![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 [<packages...>]
     -     write an archive of the device's data to  <  file  >  .
  If no -f option is supplied then the data is written
  to "backup.ab" in the current directory.
  (−apk|-noapk enable/disable backup of the .apks![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 themselves
  in the archive; the default is noapk.)
  (−shared|-noshared enable/disable backup of the![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 device's
  shared storage / SD card contents; the default is![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 noshared.)
  (−all means to back up all installed applications)
  (−system|-nosystem toggles whether -all automatically![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 includes
  system applications; the default is to include![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 system apps)
  (<packages...  >  is the list of applications to be![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 backed up. If
  the -all or -shared flags are passed, then the![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 package
  list is optional. Applications explicitly given![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 on the
  command line will be included even if –nosystem![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 would
  ordinarily cause them to be omitted.)

  adb restore  <  file> - restore device contents from the  <  file  >  backup archive

  adb help    -     show this help message
  adb version    -     show version num

scripting:
  adb wait-for-device    -     block until device is online
  adb start-server    -     ensure that there is a server running
  adb kill-server    -     kill the server if it is running
  adb get-state    -     prints: offline | bootloader | device
  adb get-serialno    -     prints: <serial-number>
  adb status-window    -     continuously print device status for a specified device
  adb remount    -     remounts the /system partition on the device read-write
  adb reboot [bootloader|recovery] - reboots the device, optionally into the![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 bootloader or recovery program
  adb reboot-bootloader    -     reboots the device into the bootloader
  adb root    -     restarts the adbd daemon with root permissions
  adb usb    -     restarts the adbd daemon listening on USB
  adb tcpip  <  port> -     restarts the adbd daemon listening on TCP on the![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 specified port
networking:
  adb ppp  <  tty  >  [parameters]    -     Run PPP over USB.
 Note: you should not automatically start a PPP connection.
 <tty  >  refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1
 [parameters] - Eg. defaultroute debug dump local notty usepeerdns

adb sync notes: adb sync [ <directory> ]
  <localdir  >  can be interpreted in several ways:

  - If  <  directory  >  is not specified, both /system and /data partitions will be updated.

  - If it is "system" or "data", only the corresponding partition
  is updated.

environmental variables:
  ADB_TRACE - Print debug information. A comma separated list of![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 the following values
  1 or all, adb, sockets, packets, rwx, usb, sync,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 sysdeps, transport, jdwp
  ANDROID_SERIAL - The serial number to connect to. -s takes priority![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 over this if given.
  ANDROID_LOG_TAGS - When used with the logcat option, only these debug![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 tags are printed.

对于希望将文件从安卓设备复制到自己电脑的人来说，拉和推命令非常有用。一般第三方 app 都存储在设备的 /data/app 目录下。首先，让我们看看应用目录 中有什么:

1. 通过键入 adb shell 打开设备的外壳。
2. 通过做 cd /data/app 将目录更改为 /data/app 。
3. 使用 ls 列出内容。

您将看到类似于以下内容的输出:

$ ./adb shell
# cd /data/app
# ls
net.zenconsult.android.chucknorris-1.apk
test_limits_host
ApiDemos.apk
test_list_host
test_set_host
CubeLiveWallpapers.apk
test_iostream_host
test_iomanip_host
SoftKeyboard.apk
test_iterator_host
test_vector_host
test_algorithm_host
test_uninitialized_host
GestureBuilder.apk
test_sstream_host
test_char_traits_host
test_memory_host
test_ios_base_host
test_type_traits_host
test_ios_pos_types_host
test_streambuf_host
test_functional_host
test_string_host

再来看 net . Zen consult . Android . chuck Norris-1 . apk 包。我们可以抄下来看看。

要从设备复制包，您可以使用命令 adb pull 。就这么办吧。键入 exit 并按回车键，退出当前的亚行 shell 会话。接下来，键入以下内容:

adb pull /data/app/ net.zenconsult.android.chucknorris-1.apk.

这将把包复制到您的当前目录。如果您想要将文件复制到计算机上的其他位置，请用您选择的目录替换句点。您现在拥有了包文件的副本，就像它离开开发人员的计算机一样。我们可以进一步研究这个文件。

逆向工程

奇怪的排序不会仅仅停留在从设备复制包文件。他们会想更仔细地看看应用和代码。这就是逆向工程发挥作用的地方。逆向工程是获取编译后的二进制程序并生成等效的汇编或源代码以提高可读性的过程。在大多数情况下，获得源代码是最理想的情况，因为阅读源代码要比阅读汇编代码容易得多。将程序逆向工程成汇编代码的过程称为反汇编，从程序生成源代码称为反编译。你要明白，每个 CPU 都会有自己的汇编器，自己的汇编语言。这就是英特尔 x86 CPU 上的汇编代码与基于 ARM–的 CPU 上的汇编代码不同的原因。不过，我们不必达到如此低的水平。通常，工作到 Dalvik VM (DVM)级别就足够了。

DVM 还包含一个汇编器。出于解释的目的，假设 DVM 是 CPU。因此，必须使用这个汇编器来构建 Java 代码，以便在 DVM 上工作。当您使用 Android SDK 构建应用时，就会发生这种情况。将在 DVM 上运行的结果可执行文件被称为 Dalvik 可执行文件 (DEX ) 文件。您用 Java 编写代码，并使用标准的 Java 编译器( javac )将其编译成 Java 类文件。然后，要将这个类文件转换成 DEX 格式，可以使用名为 dx 的命令。您也可以在您的平台工具目录中找到这个工具。一旦生成了 DEX 文件，它就被打包成一个 APK 文件。你可能已经知道，APK 文件只不过是一个压缩文件。如果我想检查我的 APK 文件中的文件，我将如下提取该文件:

$ unzip net.zenconsult.android.chucknorris-1.apk
Archive: net.zenconsult.android.chucknorris-1.apk
  inflating: res/layout/main.xml
  inflating: AndroidManifest.xml
 extracting: resources.arsc
 extracting: res/drawable-hdpi/ic_launcher.png
 extracting: res/drawable-ldpi/ic_launcher.png
 extracting: res/drawable-mdpi/ic_launcher.png
  inflating: classes.dex
  inflating: META-INF/MANIFEST.MF
  inflating: META-INF/CERT.SF
  inflating: META-INF/CERT.RSA
$

请注意 DEX 文件。

幸运的是，Eclipse 将处理整个构建过程，并确保在我们的项目中插入、对齐和打包所有相关文件。我已经在图 9-3 中展示了整个构建过程。

图 9-3 。Android 构建流程

现在，您已经对应用是如何构建的有了一个简单的概念，让我们看看如何将它们分开。正如我们在提取 APK 文件的内容时看到的，我们可以直接访问 classes.dex 文件。因为我们认为 DVM 是我们的 CPU，这是我们的二进制。就像 Win32 PE 文件或 Linux ELF 文件一样，这个 DEX 文件是我们的二进制文件，因为它运行在我们的 CPU (DVM)上。谷歌也为我们提供了名为 dexdump 的工具(也可以在你的平台工具目录中找到)。如果我在提取的 classes.dex 文件上运行 dexdump ，我将获得关于文件如何构建的大量信息，包括成员、调用等等。清单 9-2 显示了典型的 dexdump 反汇编的样子。

清单 9-2 。 输出

$ dexdump –d classes.dex
...
...
Virtual methods -
  #0 : (in Lnet/zenconsult/android/chucknorris/e;)
  name : 'a'
  type : '()Ljava/lang/String;'
  access : 0x0011 (PUBLIC FINAL)
  code -
  registers : 16
  ins : 1
  outs : 2
  insns size : 180 16-bit code units
0009d4: |[0009d4] net.zenconsult.android![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
.chucknorris.e.a:()Ljava/lang/String;
0009e4: 1202 |0000: const/4 v2, #int 0 // #0
0009e6: 1a00 5100 |0001: const-string v0,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 "[`www.chucknorrisfacts.com/`](http://www.chucknorrisfacts.com/)" // string@0051
0009ea: 7020 2900 0f00 |0003: invoke-direct {v15, v0},![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 Lnet/zenconsult/android/chucknorris/e;.a:(Ljava/lang/String;)Ljava/io/InputStream;![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 // method@0029
0009f0: 0c05 |0006: move-result-object v5
0009f2: 7100 1600 0000 |0007: invoke-static {},![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 Ljavax/xml/parsers/DocumentBuilderFactory;.newInstance:()Ljavax/xml/![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
parsers/DocumentBuilderFactory; // method@0016
0009f8: 0c00 |000a: move-result-object v0
0009fa: 1a01 0000 |000b: const-string v1, "" // string@0000
0009fe: 2206 1100 |000d: new-instance v6,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 Ljava/util/Vector; // type@0011
000a02: 7010 1000 0600 |000f: invoke-direct {v6},![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 Ljava/util/Vector;.  <  init>:()V // method@0010
000a08: 6e10 1500 0000 |0012: invoke-virtual {v0},![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
 Ljavax/xml/parsers/DocumentBuilderFactory;.newDocumentBuilder:()Ljavax/xml![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
/parsers/DocumentBuilder; // method@0015
000a0e: 0c00 |0015: move-result-object v0
000a10: 6e20 1400 5000 |0016: invoke-virtual {v0, v5},
...
...

我想你明白了。反汇编的 DEX 文件很难阅读，就像 Linux 或 Windows 上反汇编的代码一样。这不是不可能的；但对于门外汉来说，这似乎是压倒性的。

多亏了一些非常聪明的人，他们也认为反汇编的 DEX 文件很难阅读，我们现在有了反汇编器，可以生成更可读的输出。一个名叫 JesusFreke 的天才为 DEX 文件格式构建了一个全新的汇编器和反汇编器。他分别称这些斯马利和巴克斯马利；他在 http://code.google.com/p/smali/发布了开源软件。他的方法的妙处在于，你可以反汇编一个文件，修改反汇编代码，然后重新汇编成一个 DEX 文件。你可能想知道 smali 和 baksmali 有什么特别之处，所以我给你看一下 baksmali 反汇编的同一个文件的一些输出:

$ java -jar ∼/Downloads/baksmali-1.2.8.jar classes.dex
$ cd out/net/zenconsult/android/chucknorris/
$ ls
ChuckNorrisFactsActivity.smali b.smali d.smali
a.smali c.smali e.smali
$

这将文件分解成单个的文件，并且更容易检查。我们来看文件 b.smali 。清单 9-3 显示了反汇编代码。

清单 9-3 。 代码被 baks Mali反汇编

.class public final Lnet/zenconsult/android/chucknorris/b;
.super Ljava/lang/Thread;

# instance fields
.field private a:Lnet/zenconsult/android/chucknorris/a;

# direct methods
.method public constructor  <  init  >  (Lnet/zenconsult/android/chucknorris/a;)V
  .registers 2

  invoke-direct {p0}, Ljava/lang/Thread;-  >  <init  >  ()V

  iput-object p1, p0, Lnet/zenconsult/android/chucknorris/b;-  >  a:Lnet/zenconsult![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
/android/chucknorris/a;

  return-void
.end method

# virtual methods
.method public final run()V
  .registers 3

  new-instance v0, Lnet/zenconsult/android/chucknorris/e;

  invoke-direct {v0}, Lnet/zenconsult/android/chucknorris/e;-  >  <init  >  ()V

  iget-object v1, p0, Lnet/zenconsult/android/chucknorris/b;-  >  a:Lnet/zenconsult![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
/android/chucknorris/a;

  invoke-virtual {v0}, Lnet/zenconsult/android/chucknorris/e;-  >  a()Ljava/lang/String;

  move-result-object v0

  invoke-interface {v1, v0}, Lnet/zenconsult/android/chucknorris/a;-  >  a![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
(Ljava/lang/String;)V

  return-void
.end method

这并没有好到哪里去，但它明显更容易理解和遵循。另一个可以让你反汇编 DEX 文件的工具叫做 dedexer，它是由 Gabor Paller 编写的。你可以在 http://dedexer.sourceforge.net/找到。

一个明显更容易使用的工具是 dex2jar，你可以在code.google.com/p/dex2jar/找到它。这个工具帮助你解构安卓。dex 文件直接转换成 Java JAR 文件。生成 JAR 文件后，可以使用任何标准的 Java 反编译器来检索 Java 源代码。我用的是 JD-，或者 Java 反编译器，你可以在java.decompiler.free.fr/找到。

要运行 dex2jar ，只需从给定的 URL 下载并解压存档文件，然后运行。蝙蝠或。sh 文件，如图 9-4 所示。这将生成一个。jar 文件，除了它以 _dex2jar.jar 结尾之外，它的名字听起来很相似。如果在 JD-GUI 中打开这个文件，就可以看到重构后的 Java 源代码。在大多数情况下，反编译的代码可以在您的开发环境中重新编译，比如 Eclipse。

图 9-4 。在 classes.dex 文件上运行 dex 2 jarT5

图 9-5 向你展示了 JD-GUI 中反编译后的源代码是什么样子。JD-GUI 有一个简单直观的界面来浏览 JAR 文件源代码，甚至可以将源代码导出到 Java 文件中。

图 9-5 使用 JD-GUI 反编译 JAR 文件

有了这样不断发展的工具，坚定的用户下载、修改和重新打包你的应用就容易多了。如果你计划编写自己的保护机制来防止盗版，那么你有了一个好的开始。但这是你应该考虑的事情吗？我将在下一节中简要介绍这一点。

你应该许可吗？

这个问题是我看到开发者问的常见问题。你真的想花和开发你的应用一样多的时间去写一个许可程序吗？答案很主观，真的要看你的 app 是做什么的。如果你的应用有独特的或者比其他应用高效几倍的功能；或者，如果它展示了一种独特的感觉，可以确保它卖得很好，那么它可能值得考虑开发一个许可 例程。然而，请注意，当我说许可时，这并不意味着收费。你仍然可以为你的应用向用户收费；只是，如果你的应用没有监控许可的方法，那么最终用户将可以自由地复制和分发应用。

你可能会考虑开发许可程序的另一个原因是，如果你计划在未来开发更多的应用，并且你也想许可它们。在这种情况下，您可以简单地使用您已经创建的一个许可库。然而，有一点需要注意的是，你需要稍微改变每个应用的算法或许可证检查程序。因此，如果你的一个应用是盗版的，那么同样的技术将不会在其他应用上工作。

安卓许可证验证库

谷歌已经提供了 Android LVL 来帮助开发者保护他们的应用不被任意分发。将 LVL 添加到应用构建路径中，并使用其中的 API 来检查和验证用户许可。LVL 与 Android Market 应用(见图 9-6 )连接，然后与 Google market 服务器核对。根据您收到的响应，您可以选择是允许还是拒绝进一步使用应用。了解 LVL 的最好方法是在一个示例应用中使用它，我们就这么做吧。但是，在您继续之前，您需要注册成为应用发布者。不过，你现在不需要这么做。让我们从编写一个非常基本的应用开始，用它来测试我们的许可程序。清单 9-4 到 9-7 展示了这个基本应用的代码。

图 9-6 LVL 库与市场应用接口，然后与市场服务器接口

这个应用本身非常简单。它涉及到 Chuck Norris(正如你从前面的提取和逆向工程部分已经猜到的。)我们都知道也害怕查克·诺里斯。他的回旋踢是传奇性的，人们报道说它们经常是许多自然灾害的原因。为了向这位伟人致敬，我将创建一个应用，从一个名为查克·诺里斯事实( 、www.chucknorrisfacts.com/)的热门网站获取最新的查克·诺里斯事实。该应用将从该网站获取所有报价，并在我们的应用屏幕的文本区域显示随机报价。只需点击按钮获取另一个事实。我依赖于该网站报价的随机性，以确保每次都有新的报价出现。像往常一样，这个应用仅仅是一个例子，说明了你需要添加 LVL 检查的方式和位置。几乎没有错误检查，应用的功能也很少。说到这里，我不知道为什么我需要为自己辩护；这是查克·诺里斯的应用。仅此一点就足够了。你可能会注意到应用中有几个你可以改进的地方。请随意这样做。

清单 9-4 。

package net.zenconsult.android.chucknorris;

**import** android.app.Activity;
**import** android.os.Bundle;
**import** android.view.View;
**import** android.widget.Button;
**import** android.widget.TextView;

**public class** ChuckNorrisFactsActivity **extends** Activity **implements** CommsEvent {
        **private** Activity activity;
        **private** TextView view;
        **private** CommsEvent event;

        /** Called when the activity is first created. */
        @Override
        **public void** onCreate(Bundle savedInstanceState) {
                **super**.onCreate(savedInstanceState);
                setContentView(R.layout. *main* );
                activity = **this**;
                event = **this**;
                view = (TextView) findViewById(R.id.*editText1*);

                // Click Button
                **final** Button button = (Button) findViewById(R.id.*button1*);
                button.setOnClickListener(**new** View.OnClickListener() {
                        **public void** onClick(View v) {
                                view.setText("Fetching fact...");
                                CommsNotifier c = **new** CommsNotifier(event);
                                c.start();
                        }
                });
        }

        @Override
        **public void** onTextReceived(**final** String text) {
                runOnUiThread(**new** Runnable() {
                        **public void** run() {
                                view.setText(text);
                        }
                });

        }
}

清单 9-5。

**package** net.zenconsult.android.chucknorris;

**public interface** CommsEvent {
        **public void** onTextReceived(String text);
}

清单 9-6。【CommsNotifier.java】

**package** net.zenconsult.android.chucknorris;

**public class** CommsNotifier **extends** Thread {
        **private** CommsEvent event;

        **public** CommsNotifier(CommsEvent evt) {
        event = evt;
        }

        **public void** run() {
        Comms c = **new** Comms();
        event.onTextReceived(c.get());
        }
}

清单 9-7 。【Comms.java】文件

**package** net.zenconsult.android.chucknorris;

**import** java.io.IOException;
**import** java.io.InputStream;
**import** java.util.Random;
**import** java.util.Vector;

**import** javax.xml.parsers.DocumentBuilder;
**import** javax.xml.parsers.DocumentBuilderFactory;
**import** javax.xml.parsers.ParserConfigurationException;

**import** org.apache.http.HttpResponse;
**import** org.apache.http.client.ClientProtocolException;
**import** org.apache.http.client.methods.HttpGet;
**import** org.apache.http.impl.client.DefaultHttpClient;
**import** org.apache.http.util.EntityUtils;
**import** org.w3c.dom.Document;
**import** org.w3c.dom.NamedNodeMap;
**import** org.w3c.dom.Node;
**import** org.w3c.dom.NodeList;
**import** org.xml.sax.SAXException;

**import** android.app.Activity;
**import** android.content.Context;
**import** android.util.Log;
**import** android.widget.Toast;

**public class** Comms {
        **private final** String url = "[`www.chucknorrisfacts.com/`](http://www.chucknorrisfacts.com/)";

        **private** DefaultHttpClient client;

        **public** Comms() {

        client = **new** DefaultHttpClient();
        }

        **public** String get() {
        InputStream pageStream = doGetAsInputStream(url);
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.*newInstance*();
        DocumentBuilder db = **null**;
        Document doc = **null;**
        String pageText = "";
        Vector        < String >        quotes = **new** Vector        < String >        ();
        **try** {
        db = dbFactory.newDocumentBuilder();
        doc = db.parse(pageStream);
        NodeList nl = doc.getElementsByTagName("div");
        **for** (**int** x = 0; x < nl.getLength(); ++x) {
        Node node = nl.item(x);
        NamedNodeMap attributes = node.getAttributes();
        **for** (**int** y = 0; y        <        attributes.getLength(); ++y) {
        **if** (attributes.getNamedItem("class") ! = null) {
        Node attribute =![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       attributes.getNamedItem("class");
        **if** (attribute.getNodeValue()
        .equals("views-![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
field-title")) {
        NodeList children =![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       node.getChildNodes();
        **for** (**int** z = 0; z <![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       children.getLength(); ++z) {
        Node child =![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       children.item(z);
        **if** (child.getNodeName()
        ![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
.equalsIgnoreCase("span"))
        quotes.add![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
(child.getTextContent());
        }
        }
        }

        }
        }
        Random r = **new** Random();
        pageText = quotes.get(r.nextInt(quotes.size() - 1));
        pageStream.close();
        } **catch** (SAXException e) {
              // **TODO** Auto-generated **catch** block
        e.printStackTrace();
        } **catch** (IOException e) {
              // **TODO** Auto-generated catch block
        e.printStackTrace();
        } **catch** (ParserConfigurationException e) {
              // **TODO** Auto-generated catch block
        e.printStackTrace();
        }
        **return** pageText;
        }

        **public** String doGetAsString(String url) {
        HttpGet request = **new** HttpGet(url);
        String result = "";
        **try** {
        HttpResponse response = client.execute(request);
        **int** code = response.getStatusLine().getStatusCode();
        **if** (code == 200) {
        result = EntityUtils.*toString*(response.getEntity());
        } **else** {
        Log.*e*("CN", "Non 200 Status Code "        +        code);
        }
        } **catch** (ClientProtocolException e) {
              // **TODO** Auto-generated catch block
        e.printStackTrace();
        } **catch** (IOException e) {
              // **TODO** Auto-generated catch block
        e.printStackTrace();
        }
        **return** result;

        }

        **public** InputStream doGetAsInputStream(String url) {
        HttpGet request = **new** HttpGet(url);
        InputStream result = **null**;
        **try** {
        HttpResponse response = client.execute(request);
        **int** code = response.getStatusLine().getStatusCode();
        **if** (code == 200) {
        result = response.getEntity().getContent();
        } **else** {
        Log.*e*("CN", "Non 200 Status Code "        +        code);
        }
        } **catch** (ClientProtocolException e) {
              // **TODO** Auto-generated catch block
        e.printStackTrace();
        } **catch** (IOException e) {
              // **TODO** Auto-generated catch block
        e.printStackTrace();
        }
        **return** result;
        }
}

从主活动开始，您可以看到有一个按钮和一个文本视图，我们将使用它进行用户交互。当用户点击我们的按钮时，我们启动我们的 CommNotifier 线程。这个线程将执行我们的 Comms 文件中的 HTTP get 请求，并返回一个从网站上收集的 Chuck Norris 事实列表中随机选取的引用。 CommNotifier 然后触发 onTextReceived(字符串文本)函数。我们的主活动实现了 CommEvent 接口。因此，每当这个方法被触发时，我们需要访问文本参数来接收我们的报价。当我们执行应用并点击按钮时，我们会看到类似于图 9-7 所示的输出。查克·诺里斯确实很吓人。

现在我们已经有了自己的应用，让我们看看如何使用 LVL 来保护它。

图 9-7 查克·诺里斯事实应用 ?? 在行动

我将在 Android 模拟器上运行这个演示。这涉及到一个额外的步骤，因为 Android 模拟器没有预先打包到 Android Market 应用中。我需要下载 Google API 插件 平台，它提供了 Android Market 的基本后台实现。它实现了我们测试 LVL 所需的许可服务。不过，我有点言过其实了。让我们从准备我们的开发环境开始。我将假设您使用 Eclipse 进行开发，并且您已经下载并安装了 API 级别至少为 8 的 Android SDK。我们出发了！

下载谷歌 API 插件

如果您使用 Eclipse，我将描述获得 Google API 附加组件所需的步骤。首先，打开 Android SDK 管理器。选择窗口 Android SDK 管理器。接下来，导航到您计划使用的 API 级别，并勾选谷歌公司的谷歌 API(参见图 9-8 )。在点击安装按钮之前，再次导航到 Extras 文件夹并勾选 Google Market 许可包(参见图 9-9 )。现在点击安装按钮。对于这个应用，我使用 2.3.3 版本的 Android API level 10，所以这是我选择的。

图 9-8 为 Android 版本 2.3.3 安装 Google APIs

图 9-9 安装市场许可包

就是这样。Eclipse 会将您的 API 下载并安装到 SDK 目录中。要找到 LVL 源代码，请从 Android SDK 目录导航到/extras/Google/market _ licensing/library。在这里，你会看到一个类似于图 9-10 所示的目录结构。让我们进入下一组步骤，即导入、修改和构建 LVL。

图 9-10T3。LVL 来源

将 LVL 源文件复制到单独的目录下

现在我们已经有了 LVL 源代码，让我们把它移到另一个工作目录中。这样做的主要原因是，如果我们继续从原始的源目录开始工作，每当我们进行更新时，我们所有的更改都可能被覆盖。因此，我们需要将我们的 LVL 源文件保存在一个单独的目录中，这样就不会被覆盖。这很简单。将库目录以及所有子目录和文件复制到您的开发目录中。

导入 LVL 源作为库项目

我们现在将建立 LVL 图书馆。为此，我们必须创建一个新的 Eclipse Android 项目，并将该项目标记为库项目。库项目没有活动，也不直接与最终用户交互。相反，它的存在是为了让其他应用可以在它们的代码中使用它的功能。创建一个新的 Eclipse 项目，选择文件 新建 其他，打开 Android 文件夹，选择 Android 项目(参见图 9-11 )。命名您的项目(参见图 9-12 ，并选择您计划开发项目的正确 API 版本(参见图 9-13 )。您需要将您的包命名为与 LVL 源代码相同的名称，即 com . Android . vending . licensing(参见图 9-14 )。

图 9-11T3。Android 项目

图 9-12T3。命名您的项目

图 9-13T3。选择 API 版本

图 9-14T3。指定包名。它应该与 LVL 源代码包相同

完成后，让我们将 LVL 源代码导入到我们的项目中。但在此之前，我们先把项目设定为库项目。在项目资源管理器窗口中右键单击项目名称，然后选择 Properties。在左侧窗格中选择 Android 选项，在右侧窗格的下半部分，您会看到一个标记为 Is Library 的勾选框。勾选此选项并点击确定按钮(参见图 9-15 )。

图 9-15 。将项目标记为库

现在我们可以导入我们的源代码了。在“项目资源管理器”窗口中右键单击项目名称，然后选择“导入”。在出现的窗口中，选择文件系统(见图 9-16 )并点击下一步按钮。在下一个窗口中，单击 Browse 按钮并导航到作为 Android LVL 源代码一部分的 library 文件夹。在左中窗格中，您应该会看到目录出现。勾选库目录并点击完成按钮，将 LVL 源文件导入到您的项目中(参见图 9-17 )。如果要求您覆盖 AndroidManifest.xml 文件，选择 Yes。您的 LVL 源现在是项目的一部分。

图 9-16T3。导入文件系统

图 9-17T3。找到并导入源代码

在我们的 app 中建立并包含 LVL

**我们先把 Google 提供的基础版 LVL 集成到我们的 app 中。在此之后，我将解释一些可能的地方，您可以修改 LVL 源代码，使之成为您自己的。我强烈推荐这种方法，因为正如我前面提到的，您编写的 LVL 修改过的源代码不会广为人知，因此攻击者会花更长的时间来破坏您的许可模块。

要在您的应用中包含 LVL，请在 Eclipse 的 Project Explorer 视图中导航到您的应用名称，右键单击并选择 Properties。从左侧窗口窗格中选择 Android 选项，然后在右下方的窗口页面中，单击“Add”按钮。然后提示您选择一个库项目(参见图 9-18 )。选择我们刚刚创建的 Android LVL 库项目。完成后，你会看到库项目包含在你的应用的项目中(见图 9-19 )。

图 9-18 。选择 Android LVL 库项目

图 9-19T3。LVL 库项目包含在 app 项目中

现在让我们把我们的 ChuckNorrisFactsActivity.java 文件改成清单 9-8 所示的文件。你可以看到我们添加了一个新的私有类，叫做 LicCallBack 。这实现了 LVL 的 LicenseCheckerCallBack 类。当许可证检查完成时，以及当许可证服务器有肯定或否定的响应时，调用此类。分别调用 allow() 或 don 牛油()方法。

清单 9-8 。 修改后的 ChuckNorrisFactsActivity.java 文件

**package** net.zenconsult.android.chucknorris;

**import** java.util.UUID;

**import** com.android.vending.licensing.AESObfuscator;
**import** com.android.vending.licensing.LicenseChecker;
**import** com.android.vending.licensing.LicenseCheckerCallback;
**import** com.android.vending.licensing.ServerManagedPolicy;

**import** android.app.Activity;
**import** android.content.Context;
**import** android.os.Build;
**import** android.os.Bundle;
**import** android.provider.Settings.Secure;
**import** android.view.View;
**import** android.view.Window;
**import** android.widget.Button;
**import** android.widget.TextView;
**import** android.widget.Toast;

**public class** ChuckNorrisFactsActivity **extends** Activity **implements** CommsEvent {
        **private** Button button;
        **private** TextView view;
        **private** Activity activity;
        **private** CommsEvent event;
        **private** LicCallBack lcb;
        **private static** final String*PUB_KEY* = "MIIBI...";// Add your Base64 Public
        // key here
        **private** staticfinal byte[]*SALT* = **new byte**[] { −118, -112, 38, 124, 15,
        -121, 59, 93, 35, -55, 14, -15, -52, 67, -53, 54, 111, -28,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       -87, 12 };

        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
        **super**.onCreate(savedInstanceState);
        requestWindowFeature(Window.*FEATURE_INDETERMINATE_PROGRESS*);
        setContentView(R.layout.*main*);
        event = **this**;
        activity = **this**;
        view = (TextView) findViewById(R.id.*editText1*);

        // Click Button
        button = (Button) findViewById(R.id.*button1*);
        button.setOnClickListener(**new** View.OnClickListener() {
        public void onClick(View v) {
        // Do License Check before allowing click

        // Generate a Unique ID
        String deviceId = Secure.*getString*(getContentResolver(),
        Secure.*ANDROID_ID*);
        String serialId = Build.*SERIAL*;
        UUID uuid = **new** UUID(deviceId.hashCode(),![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       serialId.hashCode());
        String identity = uuid.toString();
        Context ctx = activity.getApplicationContext();

        // Create an Obfuscatorand a Policy
        AESObfuscator obf = **new** AESObfuscator(*SALT*,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       get**Package**Name(),
        identity);
        ServerManagedPolicy policy = **new**![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       ServerManagedPolicy(ctx, obf);

        // Create the LicenseChecker
        LicenseChecker lCheck = **new** LicenseChecker(ctx,![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       policy,*PUB_KEY*);

        // Do the license check
        lcb = **new** LicCallBack();
        lCheck.checkAccess(lcb);
        }
        });
        }

        @Override
        public void onTextReceived(final String text) {
        runOnUiThread(**new** Runnable() {
        public void run() {
        setProgressBarIndeterminateVisibility(**false**);
        view.setText(text);
        button.setEnabled(**true**);

        }
        });

        }

        **public class** LicCallBack implements LicenseCheckerCallback {

        @Override
        public void allow() {
        if (isFinishing()) {
        return;
        }

        Toast toast = Toast.*makeText*(getApplicationContext(),![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       "Licensed!",
        Toast.*LENGTH_LONG*);
        toast.show();
        button.setEnabled(**false**);
        setProgressBarIndeterminateVisibility(**true**);
        view.setText("Fetching fact...");
        CommsNotifier c = **new** CommsNotifier(event);
        c.start();
        }

        @Override
        public void dontAllow() {
        if (isFinishing()) {
        return;
        }
        Toast toast = Toast.*makeText*(getApplicationContext(),
        "Unlicensed!", Toast.*LENGTH_LONG*);
        toast.show();
        }

        @Override
        public void applicationError(ApplicationErrorCode errorCode) {
        // TODO Auto-generated method stub

        }

        }

}

下一件你会注意到的事情是，我们没有在我们的按钮点击上做任何活动。相反，我们做执照检查。这意味着我们将我们的报价获取活动移到了 LicenseCallBack 类的 allow() 部分。要使用来自 LVL 的许可证检查，您必须调用 LicenseChecker 类的 checkAccess() 方法。您必须使用以下参数构建 LicenseChecker:

1. 应用上下文
2. 许可政策
3. 您的公钥

对于应用上下文，您可以使用当前的应用上下文。如果您的 LicenseChecker 在另一个类中被实例化，那么您需要将应用上下文对象传递给这个类。您的 Base 64 编码公钥将位于您的在线发布者配置文件页面中。要访问它，登录 https://market.android.com/publish/Home 的，点击编辑个人资料，然后向下滚动到名为许可&应用内计费的部分。名为公钥的文本区域保存您的密钥(参见图 9-20 )。将此复制并粘贴到您的应用中。许可策略需要更多的解释，所以我将在下一节描述它。

同样，请看下面的代码:

AESObfuscator obf = new AESObfuscator(*SALT*, get**Package**Name(),identity);

当你的应用收到来自 Android 许可服务器的响应时，它需要在本地设备上存储关于这个响应的信息。将响应数据保持为纯文本形式只会意味着攻击者可以读取和篡改这些信息。为了防止这种情况发生，LVL 允许我们在将信息存储在设备上之前对其进行模糊处理。 AESObfuscator 类就是这样做的。它需要一个 salt 值(只是一个随机的 20 字节)和一个唯一的设备标识。唯一标识确保只能从具有该匹配标识的设备读取数据。在您自己的代码中，您将希望从尽可能多的信息来源中构建这个标识字符串。在这种情况下，我使用的是 ANDROID_ID 和 OS 构建序列号。

另请注意，您的应用必须请求新的权限。为了能够通过 Android Market 验证许可证，请确保将以下权限添加到 AndroidManifest.xml 文件中:

<用途-权限 Android:name =【com . Android . vending . check _ LICENSE】>

图 9-20T3。Base64 编码的公钥

您的 publisher 仪表板有一个标有测试响应的下拉菜单(参见图 9-20 )。您可以通过将该值设置为许可或非许可来测试您的应用。Google API 和 LVL 将联系 Android Market 服务器，并向您的应用提供此响应。将测试响应值设置为 NOT_LICENSED 可让您看到未经授权的用户试图使用您的应用时，您的应用会如何运行(参见图 9-21 )。相应地，您可以进行更改，或者显示一条消息(我用一个词来表示该应用是否获得许可)，或者将用户重定向到 Android Market，以便她可以购买您的应用。

图 9-21T3。一个未经许可的用户收到一个否定的回应，应用无法运行

许可政策

可以用来定制许可过程的一个关键机制是许可策略。Android LVL 附带两个默认策略 :

• 严格的政策
• 服务器管理策略

Google 建议您使用 ServerManagedPolicy，因为它还处理服务器响应的缓存。这通常很有用，因为 Google 对应用查询其服务器的次数进行了限制。StrictPolicy 将始终查询服务器；虽然这可以防止本地设备数据被篡改，从而更加安全，但如果谷歌服务器因为您达到了极限而拒绝给您响应，它可能会将您的最终用户锁定在外。

这两个策略对象都提供了您将会关注的两个基本方法: allowAccess() 和 processServerResponse() 。 allowAccess() 方法必须返回一个布尔值。当被调用时，如果选择允许访问，则返回 true；否则，返回假。请看清单 9-9 中的示例实现。

清单 9-9 。server managed policy 对象中的 allowAccess()方法 (由 Google 提供)

public boolean allowAccess() {
        long ts = System.currentTimeMillis();
        if (mLastResponse == LicenseResponse.LICENSED) {
        // Check if the LICENSED response occurred within the validity timeout.
        if (ts        <        = mValidityTimestamp) {
        // Cached LICENSED response is still valid.
        return true;
        }
        } else if (mLastResponse == LicenseResponse.RETRY &&
        ts < mLastResponseTime        +        MILLIS_PER_MINUTE) {
        // Only allow access if we are within the retry period or we haven't![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       used up our
        // max retries.
        return (ts        <        = mRetryUntil || mRetryCount        <        = mMaxRetries);
        }
        return false;
        }

您可以看到，如果该函数接收到 LicenseResponse，它将返回 true 。许可作为其回应。该函数首先检查收到的最后一个响应是否表明该应用已获得许可。然后，它检查该日期是否仍在有效期内。如果是，那么它返回真。如果日期大于有效期，则返回假。该函数还检查服务器是否要求我们继续重试，并且它在合理的重试限制和时间间隔内这样做。响应对象 mLastResponse 是从 processserveresponse()方法 中派生出来的，如清单 9-10 所示。您可以看到这个函数检查三个响应:

• 许可证响应。瑞莉
• 许可证响应。得到许可的
• 许可证响应。未获得许可

相应地，它随后设置参数， allowAccess() 方法可以读取这些参数。你会注意到另一件事。 processServerResponse() 对象中的最后一行是一个 commit() 操作。这是一种缓存功能，在该功能中，响应被混淆，然后存储在设备的共享首选项中。StrictPolicy 中不存在此部分，因为没有缓存任何数据。

清单 9-10 。ServerManagedPolicy 对象中的 processServerResponse()方法

**public void** processServerResponse(LicenseResponse response, ResponseData rawData) {

        // Update retry counter
        if (response != LicenseResponse.*RETRY*) {
        setRetryCount(0);
     } **else** {
        setRetryCount(mRetryCount        +        1);
     }

     **if** (response == LicenseResponse.*LICENSED*) {
        // Update server policy data
        Map        < String, String >        extras = decodeExtras(rawData.extra);
        mLastResponse = response;
        setValidityTimestamp(extras.get("VT"));
        setRetryUntil(extras.get("GT"));
        setMaxRetries(extras.get("GR"));
     } **else if** (response == LicenseResponse.*NOT_LICENSED*) {
        // Clear out stale policy data
        setValidityTimestamp(*DEFAULT_VALIDITY_TIMESTAMP*);
        setRetryUntil(*DEFAULT_RETRY_UNTIL*);
        setMaxRetries(*DEFAULT_MAX_RETRIES*);
     }

     setLastResponse(response);
     mPreferences.commit();
 }

```***  *****LVL 的有效使用**

如果您修改了 LVL 源代码(即您的策略)，使其成为您的应用独有的东西，那么这一努力是值得的。您可能犯的一个错误是使用 LVL 的普通实现，每个人都知道它的源代码。这使得有人更容易修补你的应用，绕过你的许可证检查程序。Justin Case 已经在 Android Police 网站上展示了这个漏洞。可以在[www . androidpolice . com/2010/08/23/exclusive-report-Google-Android-market-license-verification-easy-boxed-will-not-stop-pirates/](http://www.androidpolice.com/2010/08/23/exclusive-report-googles-android-market-license-verification-easily-circumvented-will-not-stop-pirates/)找到文章。诚然，这是一篇老文章，但它仍然展示了这样一个原则，即如果您知道源代码是什么样子，就可以很容易地理解和修改逆向工程代码。在这种情况下，Justin 在一个演示和一个实际的商业应用中演示了如何修补和绕过 LVL 检查。

Android 开发者博客的 Trevor Johns 为我们提供了另一套很好的指南。这篇文章非常值得一读，并列出了一些更有效地使用 LVL 的技巧。有一段代码非常有趣。看图 9-22 。Trevor 告诉我们，攻击者可以猜测许可和未 _ 许可常量值的响应，然后交换它们，以便未经许可的用户可以完全使用该应用。为了防止这种情况，Trevor 向我们展示了一些代码，这些代码将对响应运行 CRC32 检查；不检查常量，而是检查常量的 CRC32 检查结果。我想在这个问题上多谈一点。想象一下，如果您不运行固定值的检查，而是执行另一个 HTTP fetch 来从您自己的服务器检索响应。

![9781430240624_Fig09-22.jpg](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/9781430240624_Fig09-22.jpg)

图 9-22 。备用响应验证思路

考虑清单 9-11 中的代码。您向服务器发出一个额外的请求，并从那里检索响应代码，而不是直接与一个数字进行比较。这样做的一个好处是，你可以以任何你喜欢的方式设计你的 ServerVerifier 对象。您甚至可以设置它，使响应代码每次都发生变化。您甚至可以考虑在代码中使用质询响应来改变每次的响应。

***清单 9-11 。*** *修改验证功能*

```java
public void verify(PublicKey publicKey, int responseCode, String signedData, String![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       signature) {
        // ... Response validation code omitted for brevity ...

        // Compute a derivative version of the response code
        // Rather than comparing to a static value, why not retrieve the value from![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       a server that you control?

        java.util.zip.CRC32 crc32 = new java.util.zip.CRC32();
        crc32.update(responseCode);
        int transformedResponseCode = crc32.getValue();

        ServerVerifier sv = new ServerVerifier(); // This class will make an![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       HTTP request to your server to fetch the code.
        int serverResponse = sv.retrieveLicensedCode(); // There is no limit![image](https://gitee.com/OpenDocCN/vkdoc-android-zh/raw/master/docs/andr-app-sec/img/backarrow.jpg)
       to how you can create this routine.

        // ... put unrelated application code here ...
        // crc32(LICENSED) == 3523407757 But this part is calculated on your server.
        if (transformedResponse == serverResponse) {
        LicenseResponse limiterResponse = mDeviceLimiter.isDeviceAllowed(userId);
        handleResponse(limiterResponse, data);
        }

        ...
        ...
        ...

或者，这也可以发生在策略中(与检查硬编码的服务器响应相反):

**if** (response == LicenseResponse.*LICENSED*)

您可以通过以下方式从您信任的服务器之一检索响应来检查响应:

ServerVerifier sv = new ServerVerifier();
**if** (response == sv.getLicensedResponse())
```***  *****混淆视听**

混淆 是你需要考虑的另一个要点。它适用于软件盗版，以及知识产权盗窃。模糊处理是将源代码中的所有类名、变量名和方法名更改为随机的、不相关的名称的过程。你可能想知道为什么我的反编译应用在目录列表中有像 a.smali 、 b.smali 、 c.smali 等文件。当我使用 BakSmali 反编译我的应用时，我是在二进制文件的模糊版本上运行它的。代码混淆器确保将我的类名(如 Comms 、 CommsEvent 、 CommsNotifier 等)更改为不主动提供它们所做工作的信息的类名。此外，如果您查看这些文件，您会发现方法名和成员名都被混淆了。这对于试图对代码进行逆向工程的人来说是非常令人沮丧的，并且它可以作为对知识产权或代码盗窃的极好的威慑。

模糊处理不能保证你的代码不会被窃取或盗版。它只是让逆向工程的任务变得更加困难。Android SDK 附带了一个名为 ProGuard 的混淆器。您可以使用 ProGuard 来混淆您的任何 Java 代码。你可以在[`proguard.sourceforge.net/;`](http://proguard.sourceforge.net/;)下载它，它是免费的开源软件。Android 开发者文档强烈建议你在打包应用发布时对代码进行模糊处理。如果您使用 Eclipse，那么这是一项简单的任务。在您的项目中找到您的 project.properties 文件(参见图 9-23 )并添加这一行(参见图 9-24 ):

```java
proguard.config = proguard.cfg

注意，这一行假设您没有将 proguard.cfg 文件的位置从其默认位置移走。

图 9-23T3。项目属性文件

图 9-24T3。添加 proguard.config 属性

要导出已签名或未签名的 APK 文件，右键单击您的项目名称，选择 Android Tools，然后选择导出未签名的应用包或导出已签名的应用包(参见图 9-25 )。

图 9-25T3。导出混淆后的包

ProGuard 是一个免费的开源 Java 代码混淆器。除了混淆之外，ProGuard 还试图缩小、优化和预先验证您提供给它的代码。就缩短执行时间而言，预验证对于移动应用非常重要。预验证阶段确保 Java 类的注释方式允许 VM 更快地读取和执行一些运行时检查。在大多数情况下，使用默认的 proguard.cfg 文件就足够了。图 9-26 显示了反编译、混淆的类文件的输出。正如您所看到的，由于重命名的、看起来很神秘的类名和变量名，代码本身很难阅读。混淆并不意味着停止逆向工程；相反，它更像是一种威慑，因为重新构建被重命名的变量和类名可能需要很长时间。一些商业 Java 混淆器甚至混淆了类文件中的字符串。这使得代码更加难以逆向工程。

图 9-26T3。反编译、混淆的类文件*** ***总结

这一章专门讨论了你在应用货币化时将会面临的一些重要问题。虽然像苹果应用商店、黑莓应用世界和安卓市场这样的网站让你很容易获得收入，但你无疑将不得不面对软件盗版和知识产权盗窃等问题。你应该记住，本章讨论的主题不是灵丹妙药。它们不会完全保护您，但是它们会为您提供优势，使您的代码变得更难被攻击。在最好的情况下，攻击者会不动你的应用，因为他不想花力气对它进行逆向工程。

在这一章中，我们看了如果你的应用发现自己处于一个敌对的环境中，它会受到什么影响。我们研究了如何对你的应用进行逆向工程，并在修改后重新构建。我们展示了如何混淆你的源代码，使得攻击者更难读懂你的代码，即使是在逆向工程之后。然后，我们研究了如何检查应用中的许可，以确保最终用户不会盗版你的应用。我们通过使用 Android LVL 做到了这一点。要记住的一件事是，总是在许可检查库中编写自己的例程。这确保了你的代码是新鲜的，新的，不为人所知的。这使得逆向工程更加困难。

在发布应用之前，请记住这几个步骤。你可以在网上的developer . Android . com/guide/publishing/preparating . html找到它们的完整描述。

1. 选好包名。它将在应用的整个生命周期中起作用。
2. 关闭调试和日志记录。确保搜索调试跟踪并禁用它。
3. 清除项目目录中的备份文件或开发和测试过程中创建的其他不必要的文件。
4. 检查您的清单文件，并确保所有必需的权限都存在。确保设置了标签和图标值以及正确的版本代码和版本名称属性。
5. 检查并优化您的应用，以获得正确的 Android 版本。确保您的应用适合在不同规格的设备上运行。
6. 在你的应用中更新你的网址。这意味着删除任何本地 IP 地址和测试服务器。将它们更改为正确的生产 IP 地址。
7. 在您的应用中实施许可。*****

十、恶意软件和间谍软件

像个人电脑一样，移动智能手机也容易受到各种恶意软件的攻击。在本章中，我将把恶意软件和间谍软件统称为恶意软件。尽管我这样做了，但了解这些类型的恶意应用之间的区别是非常重要的。

恶意软件被定义为 驻留在用户电脑或智能手机上的任何恶意软件，其唯一任务是破坏数据、窃取个人信息或访问系统资源，以获得对其所在设备的完全控制。编写恶意软件的唯一目的是造成伤害；通常，恶意软件作者会编写恶意软件来针对操作系统或平台中的特定弱点。通常，恶意软件作者会希望最大化其恶意软件的传播，并寻求实现一种机制，使其软件能够将自身复制到其他类似的设备上。

间谍软件 是一个术语，用来指从设备中访问和窃取个人或私人信息的恶意软件。例如，在手机恶意软件的情况下，应用可能会跟踪最终用户的电子邮件、联系人列表、SMS 消息，甚至照片。间谍软件通常需要隐蔽并长时间驻留在设备上。因此，间谍软件作者的目标是在设备上执行很少或没有破坏性的活动，以便最终用户不知道她的数据被盗。几乎任何人都可以使用恶意软件；不再要求您知道如何自己编写恶意软件代码。

许多公司向个人、大公司甚至政府出售恶意软件(参见本章后面的案例研究)。我见过两种出售恶意软件的公司:一种卖给大型组织或政府，另一种卖给个人零售消费者。正如我们将在本章后面回顾的那样，一家大型中东电信供应器被发现在监视其整个黑莓用户群。有助于做到这一点的软件是由一家著名的专门从事合法监听的美国公司出售的。原来，源代码完全是从头开始开发的，它的唯一目的是从受感染的设备上捕获和泄露电子邮件。

另一方面，你会发现恶意软件或间谍软件被打包出售给任何愿意监视她认识的人。在大多数情况下，销售这类软件的公司会宣称“抓住出轨的配偶！”显然，这对一些人来说很有吸引力！我还将更详细地看一下这些版本的零售恶意软件。

恶意软件的四个阶段

我们可以将恶意软件操作分为四个不同但截然不同的阶段。虽然不是正式的，但这些阶段在大多数在设备上发现恶意软件的情况下都是可见的。

感染

这是恶意软件被引入设备的阶段。感染的圣杯是不涉及终端用户交互的圣杯。当恶意软件可以通过一些无害的方式复制到设备上时，就会发生这种情况，如向用户发送 SMS 消息或在无线网络上损害设备。

第二种感染方式是通过部分辅助行为。用户被要求单击恶意网站中的链接。一旦他这样做了，恶意软件就会把自己复制到设备上。攻击者通过 SMS 或电子邮件将此链接发送给用户。虽然有效，但这需要用户干预；在大多数情况下，勤奋的用户总是对点击发送给他们的随机链接持怀疑态度。

最后一种感染形式是攻击者通过 USB 端口或浏览网站，将恶意软件物理复制到设备上。这发生在攻击者和终端用户彼此认识，或者攻击者可以物理访问终端用户的设备的情况下。如果用户对其设备进行了密码保护，并且需要密码才能使用设备或在设备上安装应用，则此技术无效。

妥协

大多数情况下，感染和妥协是相伴而生的。在这种情况下，我使用单词 compromise 来描述恶意软件如何能够获得对设备的超级用户访问。因此，恶意软件可以以它选择的任何方式对设备配置进行更改 — ，而不需要设备所有者的交互。

正如我们在前面章节中看到的，运行在 Android 上的程序需要用户明确授权才能访问互联网或阅读电子邮件。在危害阶段，恶意软件将利用操作系统中的弱点来规避权限授予过程，从而允许它在用户不知情的情况下执行任何功能。

传播

除非专门针对个人，否则恶意软件作者通常会想要感染大量用户。他可能想要控制一大批设备，或者只是从许多不同的人那里获取私人信息。Zeus 特洛伊木马(在个人计算机平台上发现)将利用操作系统中的弱点进行传播。它的唯一目的是收集用户的按键，并收集银行和社交网站的凭据。

最近，另一种流行的传播甚至感染机制是使用谷歌 Android 市场(作者可以在这里出售或免费分发他们的应用)。恶意软件作者可以将游戏或社交网络互动工具等看起来无害的应用上传到 Android Market。当最终用户购买或下载该应用时，她的设备就会被感染。

渗出

恶意软件通常以个人或机密信息为目标。它可能会记录击键，试图获取网上银行和电子邮件等网站的用户名或密码。然而，仅仅收集这些信息是不够的。攻击者需要访问这些信息，因此恶意软件会找到一种“呼叫总部”或与远程服务器通信的方式，要么接收新的指令，要么上传捕获的信息。这个阶段叫做渗出。让我们来看一个案例研究，说明这是如何工作的。

案例研究 1:政府批准的恶意软件

2009 年 7 月，阿拉伯联合酋长国(UAE)的电信供应器 Etisalat 向其所有黑莓手机用户发送了一条短信,要求下载并安装系统补丁。该补丁旨在提高手机 3G 功能的性能。原来，这个“补丁”只不过是一个恶意软件，旨在读取每个用户的外发电子邮件。

直到今天，该公司仍坚称该补丁旨在提高性能。大多数检查过该恶意软件的研究人员，包括我自己和 Research In Motion (RIM )，都可以看到它没有任何性能上的好处。相反，检查代码会发现有人故意试图捕获设备所有者的所有外发电子邮件，并将其副本发送到供应器的服务器进行检查。

这个案件的标题，政府批准的恶意软件，可能有点强，特别是当你考虑到没有确凿的证据已经从这个案件的调查具体化。我选择这个标题是基于我在阿联酋工作的 11 年(其中 5 年为 Etisalat 工作)、最近的媒体事件，以及我对政府和监管机构控制该国媒体和通信基础设施的密切程度的了解。

我提到的媒体事件发生在 2010 年 8 月左右，当时阿联酋政府宣布，如果 RIM 公司不提供监控用户信息的手段，包括电子邮件和 BlackBerry Messenger(允许黑莓用户相互发送信息的本地消息平台)，它将关闭该国境内的所有黑莓服务。由于我不是在写间谍小说，我将为我的下一本书搁置我所有的理论，而是带你了解恶意软件本身的一些更真实的方面。在本案例研究中，我们将尝试唯一确定恶意软件感染的阶段。

感染

Etisalat 通过使用简单的 WAP-push 消息将恶意软件引入其用户的设备。这是一条出现在设备的 SMS 收件箱中的消息，它包含文本和 URL。WAP-push 消息的文本如下:

亲爱的 Etisalat BlackBerry 客户:

Etisalat 始终热衷于为您提供最佳的黑莓服务和终极体验，为此，我们将向您发送一个性能增强补丁，您需要将其安装在您的设备上。如需更多信息，请拨打 101

借助 Etisalat 的黑莓和移动解决方案提升您的业务

一旦用户点击附带的 URL，设备就会下载并安装一个名为 Registration 的应用。该设备将提示终端用户授予应用特定的权限。由于 WAP-push 消息来自看似合法的来源，大多数用户没有理由不信任该请求，并且通常授予应用完全权限。

妥协

在这种情况下，恶意软件没有依靠操作系统中的弱点来获取个人信息。用户认为应用是合法的，因此在安装阶段授予了所有必要的权限。

传播

Etisalat 发布的恶意软件旨在保留在设备上并收集信息。它不是为传播到其他设备而设计的。恶意软件依赖于 WAP-push 消息，而不是传播。安装将一次性完成，此后不会扩散。

渗出

这是 Etisalat 恶意软件最重要的阶段。它被设计成将自己附加到用户发送的电子邮件中，并向 Etisalat 内部的服务器发送每条外发邮件的副本。这由内置的 BlackBerry API 调用来完成。

图 10-1 中描述了一条真实的消息(恶意软件用来向服务器登记)。这是一条每小时发送到服务器的消息。然后，恶意软件系统的操作员可以看到哪些设备被恶意软件感染，包括哪些设备定期检查。

图 10-1T3。注册恶意软件使用的捕获的“心跳”消息

检测

这种特定的恶意软件之所以被检测出来，是因为它写得很糟糕。恶意软件一发布，本应接收泄漏数据的服务器就被信息淹没了。无法承受负载，服务器崩溃。这导致设备上的恶意软件不断重试连接到无响应的服务器。这种持续的连接尝试增加了设备本身的处理器使用率。

此时，最终用户开始注意到他们的设备性能缓慢，电池过早耗尽。一些用户甚至注意到他们的设备过热。这促使几名研究人员调查注册应用，于是他们发现这实际上是恶意软件。图 10-2 显示了恶意软件安装在设备上时如何运行的流程图。以下是注册恶意软件特征的详细列表:

• 它检查它是否在 BlackBerry 安装的应用中被列为可见。
• 如果它是可见的，它会隐藏自己，不让订阅者看到。这可以防止用户找到并删除它。
• 它遍历手持设备上的所有邮件帐户，并将自己附加到每个帐户上，查找收到的电子邮件和 PIN 消息。
• 它截取并监控手持设备的状态，以发现发生的网络事件。当这些事件发生时，它通知服务供应器的服务器。
• 它监听通过电子邮件或 BlackBerry PIN 从特定地址收到的消息。这些控制消息可以启用或禁用对用户消息的拦截。
• 它定期向预定义的服务供应器服务器报告。
• 如果启用，应用会将订户发出的电子邮件的副本转发到服务供应器服务器。

图 10-2T3。Etisalat 恶意软件操作流程图

案例研究 2:零售恶意软件—FlexiSPY

现在让我们看看第二个恶意软件应用:FlexiSPY，一种零售恶意软件。当攻击者在目标设备上安装 FlexiSPY 时，它会窃听所有通信。最新版本的 FlexiSPY Omni 为 Android 用户提供了以下功能:

• 捕获短信和电子邮件
• 捕获通话记录
• 通过 GPS 和手机信号塔信息发现 GPS 位置
• 把手机变成监听设备
• 拦截电话
• SIM 卡更换通知

对于监视任何人来说，这似乎已经足够了，我发现这个特性列表非常有趣，足以获得一个副本并对其进行分析。

注意本着全面披露的精神，我要提一下，在我评估 FlexiSPY 的时候，我查看了黑莓版本，因为那是我的主要手机。激活和启用设备的协议都是基于网络的，所以它们或多或少保持相同，不管支持的设备平台是什么(当然包括 Android)。

一旦买家支付了 349 美元，她就会收到一本用户手册，上面提供了如何在目标客户的手机上安装该应用的信息。当浏览用户手册时，首先映入我眼帘的是它提供了。。。明确指示 将黑莓手持设备的默认权限设置为允许所有 。

这意味着，不仅仅是 FlexiSPY，目标安装在手机上的每一个应用都可以获得对手持设备的完全控制(在编程接口或 API 的范围内)。显然，在这种情况下，用户保护并不是最重要的。类似地，查看 FlexiSPY 的 Android 手册，在您可以成功地在设备上安装恶意软件之前，设备本身必须是根。该网站以超级一键点击的形式提供了一个根设备的解决方案。除了这段文字，该网站没有提供直接链接。找到漏洞是客户的责任。

FlexiSPY 需要激活才能开始监视目标。为此，用户必须拨打号码 *#900900900 ，这将激活一个隐藏的屏幕。在此屏幕上，系统会提示用户输入激活码。从来没有一个离开家没有我最喜欢的网络数据包嗅探器，Wireshark，我嗅探了激活过程中通过的流量。以下是通过网络传递的信息:

• 邮件/t4l-mcli/cmd/productactivate？模式=【0】&【查看】【0302】&【PID =【FSP _ bb _ v 4.2】&【act code】【启用代码】&散列=)

此请求是向具有下列二级域的服务器发出的:

aabackup.info

它解析为与之前列出的主机 djp.cc 相同的 IP 地址。正如你所看到的，手机的 IMEI 被发送回 FlexiSPY 总部。还可以看到激活码，它返回一个哈希值。看起来手机计算了一个类似的算法，并等待一个匹配的散列。一旦收到正确的散列，应用就被激活。

从这一点上说，这是一个配置应用拦截短信，电子邮件，通话记录，等等。该应用有一个通过短信的命令通道。因此，您有一个包含八个命令的列表，它们执行以下操作:

• 开始捕获:开始捕获事件，如电子邮件、SMS、位置等。
• 停止捕获:停止已经开始的捕获。
• 立即发送:将所有收集的事件发送到中央日志记录主机。
• 发送诊断信息:发送诊断信息。
• 启动 SIM 卡监视器:观察任何改变 SIM 卡的企图。
• 停止 SIM 卡监控:停止监控 SIM 卡。
• 启动麦克风监听:等待触发号码的来电。
• 停止麦克风监听:停止监听来自该触发号码呼叫。

有趣的是，命令频道 SMS 消息不能被删除，所以手册建议用户选择像“早上好”或类似的短语来开始捕捉信息。措辞应该选择得不会引起目标的怀疑。

请记住，我在 BlackBerry 版本的 FlexiSPY 上执行了前面的检查。考虑到运行 Java 的每个平台的相似性，Android 也会以相似的方式运行。

反取证

目前，最广泛使用的检测机制 是基于签名的。这意味着任何反恶意软件公司编写删除或检测功能需要事先了解恶意软件。如果它遇到它，那么它可以删除它。因此，不太可能检测到新的恶意软件。这是不幸的，因为如果反恶意软件公司无法跟上恶意软件的发展，那么从恶意软件发布到发现并解决它总是有一个滞后。在此滞后期间，所有用户都面临风险。

*作为开发人员，您无法直接控制用户是否选择安装反恶意软件应用。您的责任在于确保您的应用安全地处理其数据。我们在前面的章节中已经介绍了这些技术中的大部分，但是我想强调另一个可用的、非正统的选项:反取证。

反取证是一种 技术，用于通过降低可收集信息的质量来挫败对计算机或移动设备的取证分析。法医分析包括检查这种设备的证据。大多数情况下，需要收集的证据非常脆弱。反取证试图通过使用定期运行的自动化工具来销毁这些信息。然后，当进行法医分析时，调查人员只会发现乱码或无用的数据。这大大降低了可检索信息的质量。我们可以使用类似的技术来阻止恶意软件的行为。

我将从一个简单的例子开始:假设您的应用读写设备的消息存储。既然可以接触到这些数据，就可以人为生成邮件信息，随意删除。假设在设备上安装了等待复制进入收件箱的消息的恶意软件应用。通过生成许多虚假消息，然后定期删除它们，您正在为恶意软件提供低质量、无用的数据。如果操作正确，这个过程会使恶意软件作者提取有效信息变得非常繁琐。这个概念在图 10-3 和图 10-4 中进行了说明。

图 10-3T3。恶意软件拦截邮件信息

图 10-4T3。生成假消息

这种技术可以被认为有点咄咄逼人；显然，最终用户应该同意您的应用的这种行为。我在这里提到它是作为另一种要考虑的技术。至于如何想出击败恶意软件的额外机制，我将留给你的想象力。然而，除非你的主要目标是开发这样的反恶意软件应用，否则你可以选择跳过它们。

摘要

在本章中，我们看了恶意软件和间谍软件以及它们是什么。我们还研究了恶意软件的各个阶段，以及我们如何将它们分成几大类。我们了解到恶意软件可以被任何人使用，并且有许多商业实体向个人和公司消费者提供恶意软件。我们的案例研究涉及 2009 年发生的真实世界恶意软件感染，当时阿联酋的电信供应器之一 Etisalat 将其整个黑莓用户群置于间谍软件应用之下。

我们已经看到，作为一名应用开发人员，您通常在控制什么样的恶意软件被引入设备方面能力有限。相反，您的目标是安全地处理应用的数据(和最终用户数据)。我们非常简要地讨论了一个主题，即如何使用一些反取证技术有目的地向恶意软件提供无用的数据，从而迫使恶意软件作者费力地通过这些消息找到真正的消息。虽然这绝不是一个万无一失的解决方案，但这种技术主要是作为一种威慑。除非恶意软件作者专门针对你，否则他不太可能浪费时间筛选无用的数据。相反，他会把注意力转移到下一个被他感染的人身上。*

十一、附录一：Android 权限常量

出于参考目的，本附录提供了 Android 权限常量 的完整列表。许可和它们的使用在整本书中都有讨论，尤其是在第三章。

内容供应器类别