Android 网络防火墙的实现 Iptables解决方案

最新推荐文章于 2022-07-25 15:41:50 发布

韩半仙

最新推荐文章于 2022-07-25 15:41:50 发布

阅读量3.4k

点赞数

Android 专栏收录该内容

157 篇文章 7 订阅

订阅专栏

通过对Android SDK帮助文档的阅读，我没有发现Android的高层提供的API，于是通过更底层考虑，我发现了可以采用Iptables实现防火墙的功能。而且Linux下主流的防火墙也是Iptables。

Iptables的介绍：

iptables 是与最新的 2.6.x 版本 Linux 内核集成的 IP 信息包过滤系统。如果 Linux 系统连接到因特网或 LAN、服务器或连接 LAN 和因特网的代理服务器，则该系统有利于在 Linux 系统上更好地控制 IP 信息包过滤和防火墙配置。

其工作原理:

netfilter/iptables IP 信息包过滤系统是一种功能强大的工具，可用于添加、编辑和除去规则，这些规则是在做信息包过滤决定时，防火墙所遵循和组成的规则。这些规则存储在专用的信息包过滤表中，而这些表集成在 Linux 内核中。在信息包过滤表中，规则被分组放在我们所谓的链（chain）中。我马上会详细讨论这些规则以及如何建立这些规则并将它们分组在链中。

虽然 netfilter/iptables IP 信息包过滤系统被称为单个实体，但它实际上由两个组件 netfilter和 iptables 组成。

netfilter 组件也称为内核空间（kernelspace），是内核的一部分，由一些信息包过滤表组成，这些表包含内核用来控制信息包过滤处理的规则集。

iptables 组件是一种工具，也称为用户空间（userspace），它使插入、修改和除去信息包过滤表中的规则变得容易。除非您正在使用 Red Hat Linux 7.1或更高版本，否则需要从 netfilter.org 下载该工具并安装使用它。

通过使用用户空间，可以构建自己的定制规则，这些规则存储在内核空间的信息包过滤表中。这些规则具有目标，它们告诉内核对来自某些源、前往某些目的地或具有某些协议类型的信息包做些什么。如果某个信息包与规则匹配，那么使用目标 ACCEPT 允许该信息包通过。还可以使用目标 DROP 或REJECT 来阻塞并杀死信息包。对于可对信息包执行的其它操作，还有许多其它目标。

根据规则所处理的信息包的类型，可以将规则分组在链中。处理入站信息包的规则被添加到 INPUT 链中。处理出站信息包的规则被添加到 OUTPUT 链中。处理正在转发的信息包的规则被添加到 FORWARD 链中。这三个链是基本信息包过滤表中内置的缺省主链。另外，还有其它许多可用的链的类型（如 PREROUTING 和 POSTROUTING ），以及提供用户定义的链。每个链都可以有一个策略，它定义“缺省目标”，也就是要执行的缺省操作，当信息包与链中的任何规则都不匹配时，执行此操作。

建立规则并将链放在适当的位置之后，就可以开始进行真正的信息包过滤工作了。这时内核空间从用户空间接管工作。当信息包到达防火墙时，内核先检查信息包的头信息，尤其是信息包的目的地。我们将这个过程称为路由。

如果信息包源自外界并前往系统，而且防火墙是打开的，那么内核将它传递到内核空间信息包过滤表的 INPUT 链。如果信息包源自系统内部或系统所连接的内部网上的其它源，并且此信息包要前往另一个外部系统，那么信息包被传递到 OUTPUT 链。类似的，源自外部系统并前往外部系统的信息包被传递到 FORWARD 链。

接下来，将信息包的头信息与它所传递到的链中的每条规则进行比较，看它是否与某条规则完全匹配。如果信息包与某条规则匹配，那么内核就对该信息包执行由该规则的目标指定的操作。但是，如果信息包与这条规则不匹配，那么它将与链中的下一条规则进行比较。最后，如果信息包与链中的任何规则都不匹配，那么内核将参考该链的策略来决定如何处理该信息包。理想的策略应该告诉内核 DROP 该信息包。下图用图形说明了这个信息包过滤过程。

使用Iptables进行防火墙软件设计的解决方案。

由于Iptables已经有了完善的防火墙规则，我们只需要设计一个基于Iptables的Android前台即可，通过运行脚本，调用iptables设置防火墙规则即可。

大家可以学习下Droid wall的源代码

[java] view plain copy

package com.googlecode.droidwall;
/**
* Contains shared programming interfaces.
* All iptables "communication" is handled by this class.
*
* Copyright (C) 2009 Rodrigo Zechin Rosauro
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @author Rodrigo Zechin Rosauro
* @version 1.0
*/
import <a href="http://lib.csdn.net/base/javase" class='replace_word' title="Java SE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;
import android.app.AlertDialog;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.util.Log;
/**
* Contains shared programming interfaces.
* All iptables "communication" is handled by this class.
*/
public final class Api {
public static final String VERSION = "1.3.6";
// Preferences
public static final String PREFS_NAME = "DroidWallPrefs";
public static final String PREF_ALLOWEDUIDS = "AllowedUids";
public static final String PREF_PASSWORD = "Password";
public static final String PREF_MODE = "BlockMode";
public static final String PREF_ITFS = "Interfaces";
// Modes
public static final String MODE_WHITELIST = "whitelist";
public static final String MODE_BLACKLIST = "blacklist";
// Interfaces
public static final String ITF_3G = "2G/3G";
public static final String ITF_WIFI = "Wi-fi";
// Cached applications
public static DroidApp applications[] = null;
// Do we have "Wireless Tether for Root Users" installed?
public static String hastether = null;
// Do we have root access?
private static boolean hasroot = false;
/**
* Display a simple alert box
* @param ctx context
* @param msg message
*/
public static void alert(Context ctx, CharSequence msg) {
if (ctx != null) {
new AlertDialog.Builder(ctx)
.setNeutralButton(android.R.string.ok, null)
.setMessage(msg)
.show();
}
}
/**
* Purge and re-add all rules (internal implementation).
* @param ctx application context (mandatory)
* @param uids list of selected uids to allow or disallow (depending on the working mode)
* @param showErrors indicates if errors should be alerted
*/
private static boolean applyIptablesRulesImpl(Context ctx, List<Integer> uids, boolean showErrors) {
if (ctx == null) {
return false;
}
final SharedPreferences prefs = ctx.getSharedPreferences(PREFS_NAME, 0);
final boolean whitelist = prefs.getString(PREF_MODE, MODE_WHITELIST).equals(MODE_WHITELIST);
boolean wifi = false; // Wi-fi selected ?
final String itfs = prefs.getString(PREF_ITFS, ITF_3G);
String itfFilter;
if (itfs.indexOf("|") != -1) {
itfFilter = ""; // Block all interfaces
wifi = true;
} else if (itfs.indexOf(ITF_3G) != -1) {
itfFilter = "-o rmnet+";; // Block all rmnet interfaces
} else {
itfFilter = "-o tiwlan+";; // Block all tiwlan interfaces
wifi = true;
}
final StringBuilder script = new StringBuilder();
try {
int code;
script.append("iptables -F || exit/n");
final String targetRule = (whitelist ? "ACCEPT" : "REJECT");
if (whitelist && wifi) {
// When "white listing" Wi-fi, we need ensure that the dhcp and wifi users are allowed
int uid = android.os.Process.getUidForName("dhcp");
if (uid != -1) script.append("iptables -A OUTPUT " + itfFilter + " -m owner --uid-owner " + uid + " -j ACCEPT || exit/n");
uid = android.os.Process.getUidForName("wifi");
if (uid != -1) script.append("iptables -A OUTPUT " + itfFilter + " -m owner --uid-owner " + uid + " -j ACCEPT || exit/n");
}
for (Integer uid : uids) {
script.append("iptables -A OUTPUT " + itfFilter + " -m owner --uid-owner " + uid + " -j " + targetRule + " || exit/n");
}
if (whitelist) {
script.append("iptables -A OUTPUT " + itfFilter + " -j REJECT || exit/n");
}
StringBuilder res = new StringBuilder();
code = runScriptAsRoot(script.toString(), res);
if (showErrors && code != 0) {
String msg = res.toString();
Log.e("DroidWall", msg);
// Search for common error messages
if (msg.indexOf("Couldn't find match `owner'") != -1 || msg.indexOf("no chain/target match") != -1) {
alert(ctx, "Error applying iptables rules./nExit code: " + code + "/n/n" +
"It seems your Linux kernel was not compiled with the netfilter /"owner/" module enabled, which is required for Droid Wall to work properly./n/n" +
"You should check if there is an updated version of your Android ROM compiled with this kernel module.");
} else {
// Remove unnecessary help message from output
if (msg.indexOf("/nTry `iptables -h' or 'iptables --help' for more information.") != -1) {
msg = msg.replace("/nTry `iptables -h' or 'iptables --help' for more information.", "");
}
// Try `iptables -h' or 'iptables --help' for more information.
alert(ctx, "Error applying iptables rules. Exit code: " + code + "/n/n" + msg.trim());
}
} else {
return true;
}
} catch (Exception e) {
if (showErrors) alert(ctx, "error refreshing iptables: " + e);
}
return false;
}
/**
* Purge and re-add all saved rules (not in-memory ones).
* This is much faster than just calling "applyIptablesRules", since it don't need to read installed applications.
* @param ctx application context (mandatory)
* @param showErrors indicates if errors should be alerted
*/
public static boolean applySavedIptablesRules(Context ctx, boolean showErrors) {
if (ctx == null) {
return false;
}
final String savedNames = ctx.getSharedPreferences(PREFS_NAME, 0).getString(PREF_ALLOWEDUIDS, "");
List<Integer> uids = new LinkedList<Integer>();
if (savedNames.length() > 0) {
// Check which applications are allowed
final StringTokenizer tok = new StringTokenizer(savedNames, "|");
while (tok.hasMoreTokens()) {
uids.add(android.os.Process.getUidForName(tok.nextToken()));
}
}
return applyIptablesRulesImpl(ctx, uids, showErrors);
}
/**
* Purge and re-add all rules.
* @param ctx application context (mandatory)
* @param showErrors indicates if errors should be alerted
*/
public static boolean applyIptablesRules(Context ctx, boolean showErrors) {
if (ctx == null) {
return false;
}
final SharedPreferences prefs = ctx.getSharedPreferences(PREFS_NAME, 0);
List<Integer> uidsToApply = new LinkedList<Integer>();
final DroidApp[] apps = getApps(ctx);
// Builds a pipe-separated list of names
final StringBuilder newnames = new StringBuilder();
for (int i=0; i<apps.length; i++) {
if (apps[i].selected) {
if (newnames.length() != 0) newnames.append('|');
newnames.append(apps[i].username);
uidsToApply.add(apps[i].uid);
}
}
// save the new list of names if necessary
if (!newnames.toString().equals(prefs.getString(PREF_ALLOWEDUIDS, ""))) {
Editor edit = prefs.edit();
edit.putString(PREF_ALLOWEDUIDS, newnames.toString());
edit.commit();
}
return applyIptablesRulesImpl(ctx, uidsToApply, showErrors);
}
/**
* Purge all iptables rules.
* @param ctx context optional context for alert messages
* @return true if the rules were purged
*/
public static boolean purgeIptables(Context ctx) {
StringBuilder res = new StringBuilder();
try {
int code = runScriptAsRoot("iptables -F || exit/n", res);
if (code != 0) {
alert(ctx, "error purging iptables. exit code: " + code + "/n" + res);
return false;
}
return true;
} catch (Exception e) {
alert(ctx, "error purging iptables: " + e);
return false;
}
}
/**
* Display iptables rules output
* @param ctx application context
*/
public static void showIptablesRules(Context ctx) {
try {
final StringBuilder res = new StringBuilder();
runScriptAsRoot("iptables -L/n", res);
alert(ctx, res);
} catch (Exception e) {
alert(ctx, "error: " + e);
}
}
/**
* @param ctx application context (mandatory)
* @return a list of applications
*/
public static DroidApp[] getApps(Context ctx) {
if (applications != null) {
// return cached instance
return applications;
}
hastether = null;
// allowed application names separated by pipe '|' (persisted)
final String savedNames = ctx.getSharedPreferences(PREFS_NAME, 0).getString(PREF_ALLOWEDUIDS, "");
String allowed[];
if (savedNames.length() > 0) {
// Check which applications are allowed
final StringTokenizer tok = new StringTokenizer(savedNames, "|");
allowed = new String[tok.countTokens()];
for (int i=0; i<allowed.length; i++) {
allowed[i] = tok.nextToken();
}
// Sort the array to allow using "Arrays.binarySearch" later
Arrays.sort(allowed);
} else {
allowed = new String[0];
}
try {
final PackageManager pkgmanager = ctx.getPackageManager();
final List<ApplicationInfo> installed = pkgmanager.getInstalledApplications(0);
final HashMap<Integer, DroidApp> map = new HashMap<Integer, DroidApp>();
String name;
DroidApp app;
for (final ApplicationInfo apinfo : installed) {
app = map.get(apinfo.uid);
name = pkgmanager.getApplicationLabel(apinfo).toString();
// Check for the tethering application (which causes conflicts with Droid Wall)
if (apinfo.packageName.equals("android.tether")) {
hastether = name;
}
if (app == null) {
app = new DroidApp();
app.uid = apinfo.uid;
app.username = pkgmanager.getNameForUid(apinfo.uid);
app.names = new String[] { name };
map.put(apinfo.uid, app);
} else {
final String newnames[] = new String[app.names.length + 1];
System.arraycopy(app.names, 0, newnames, 0, app.names.length);
newnames[app.names.length] = name;
app.names = newnames;
}
// check if this application is allowed
if (!app.selected && Arrays.binarySearch(allowed, app.username) >= 0) {
app.selected = true;
}
}
/* add special applications to the list */
final DroidApp special[] = {
new DroidApp(android.os.Process.getUidForName("root"), "root", "(Applications running as root)", false),
new DroidApp(android.os.Process.getUidForName("media"), "media", "Media server", false),
};
for (int i=0; i<special.length; i++) {
app = special[i];
if (app.uid != -1 && !map.containsKey(app.uid)) {
// check if this application is allowed
if (Arrays.binarySearch(allowed, app.username) >= 0) {
app.selected = true;
}
map.put(app.uid, app);
}
}
applications = new DroidApp[map.size()];
int index = 0;
for (DroidApp application : map.values()) applications[index++] = application;
return applications;
} catch (Exception e) {
alert(ctx, "error: " + e);
}
return null;
}
/**
* Check if we have root access
* @param ctx optional context to display alert messages
* @return boolean true if we have root
*/
public static boolean hasRootAccess(Context ctx) {
if (hasroot) return true;
try {
// Run an empty script just to check root access
if (runScriptAsRoot("exit 0", null, 20000) == 0) {
hasroot = true;
return true;
}
} catch (Exception e) {
}
alert(ctx, "Could not acquire root access./n" +
"You need a rooted phone to run Droid Wall./n/n" +
"If this phone is already rooted, please make sure Droid Wall has enough permissions to execute the /"su/" command.");
return false;
}
/**
* Runs a script as root (multiple commands separated by "/n").
*
* @param script the script to be executed
* @param res the script output response (stdout + stderr)
* @param timeout timeout in milliseconds (-1 for none)
* @return the script exit code
*/
public static int runScriptAsRoot(String script, StringBuilder res, final long timeout) {
final ScriptRunner runner = new ScriptRunner(script, res);
runner.start();
try {
if (timeout > 0) {
runner.join(timeout);
} else {
runner.join();
}
if (runner.isAlive()) {
// Timed-out
runner.interrupt();
runner.destroy();
runner.join(50);
}
} catch (InterruptedException ex) {}
return runner.exitcode;
}
/**
* Runs a script as root (multiple commands separated by "/n") with a default timeout of 5 seconds.
*
* @param script the script to be executed
* @param res the script output response (stdout + stderr)
* @param timeout timeout in milliseconds (-1 for none)
* @return the script exit code
* @throws IOException on any error executing the script, or writing it to disk
*/
public static int runScriptAsRoot(String script, StringBuilder res) throws IOException {
return runScriptAsRoot(script, res, 15000);
}
/**
* Small structure to hold an application info
*/
public static final class DroidApp {
/** linux user id */
int uid;
/** application user name (Android actually uses a package name to identify) */
String username;
/** application names belonging to this user id */
String names[];
/** indicates if this application is selected (checked) */
boolean selected;
/** toString cache */
String tostr;
public DroidApp() {
}
public DroidApp(int uid, String username, String name, boolean selected) {
this.uid = uid;
this.username = username;
this.names = new String[] {name};
this.selected = selected;
}
/**
* Screen representation of this application
*/
@Override
public String toString() {
if (tostr == null) {
final StringBuilder s = new StringBuilder(uid + ": ");
for (int i=0; i<names.length; i++) {
if (i != 0) s.append(", ");
s.append(names[i]);
}
tostr = s.toString();
}
return tostr;
}
}
/**
* Internal thread used to execute scripts as root.
*/
private static final class ScriptRunner extends Thread {
private final String script;
private final StringBuilder res;
public int exitcode = -1;
private Process exec;
/**
* Creates a new script runner.
* @param script script to run
* @param res response output
*/
public ScriptRunner(String script, StringBuilder res) {
this.script = script;
this.res = res;
}
@Override
public void run() {
try {
// Create the "su" request to run the command
// note that this will create a shell that we must interact to (using stdin/stdout)
exec = Runtime.getRuntime().exec("su");
final OutputStreamWriter out = new OutputStreamWriter(exec.getOutputStream());
// Write the script to be executed
out.write(script);
// Ensure that the last character is an "enter"
if (!script.endsWith("/n")) out.write("/n");
out.flush();
// Terminate the "su" process
out.write("exit/n");
out.flush();
final char buf[] = new char[1024];
// Consume the "stdout"
InputStreamReader r = new InputStreamReader(exec.getInputStream());
int read=0;
while ((read=r.read(buf)) != -1) {
if (res != null) res.append(buf, 0, read);
}
// Consume the "stderr"
r = new InputStreamReader(exec.getErrorStream());
read=0;
while ((read=r.read(buf)) != -1) {
if (res != null) res.append(buf, 0, read);
}
// get the process exit code
if (exec != null) this.exitcode = exec.waitFor();
} catch (InterruptedException ex) {
if (res != null) res.append("/nOperation timed-out");
} catch (Exception ex) {
if (res != null) res.append("/n" + ex);
} finally {
destroy();
}
}
/**
* Destroy this script runner
*/
public synchronized void destroy() {
if (exec != null) exec.destroy();
exec = null;
}
}
}

实质就是通过运行IPTABLES的脚本来实现防火墙规则的定制

1、简介

Droidwall是一个关于网络防火墙的开源项目，其最大的功能在于控制应用进程的上网权限，核心功能实现是通过调用linux iptables命令。

2、功能

现Droidwall开源项目提供的功能：

1）分为两种模式，blacklist和whitelist，blacklist中文释义“黑名单”，禁用的进程；whitelist也即是允许能上网的进程。

2）管理有使用网络权限的进程，最核心的功能，当我们选择好所有的进程后点击menu中的应用规则，iptables就会对相应的进程进行管理。

3）log管理

4）显示规则

5）自定义用户脚本

3、实现原理3.1 iptables 简介

防火墙分为硬件和软件，硬件cisco netscreen 联想天融信，软件Iptables 包过滤防火墙。

3.1.1 iptables功能

它最核心功能就是根据预设的规则对包进行过滤，达到保护网络安全的目的，以下是过滤包的简单示意图。

当一个网络封包要进入到主机之前，会先经由Filter表进行检查，检查通过则接受 (ACCEPT) 进入本机取得资源，如果检查不通过，则可能予以丢弃 (DROP) 。

3.1.2 版本发展

根据linux内核的发展，不同核心版本使用不同的防火墙软体

Version 2.0：使用 ipfwadm 这个防火墙机制；

Version 2.2：使用的是 ipchains 这个防火墙机制；

Version 2.4 与 2.6 ：主要是使用 iptables 这个防火墙机制，不过在某些早期的 Version 2.4 版本亦同时支持 ipchains，好让用户仍然可以使用来自 2.2 版的 ipchains 的防火墙规则，现在基本上都是用iptables。

3.1.3相关命令

1）iptables表

首先从iptables 的名称说起，为什么称为ip"tables" 呢？因为这个防火墙软件里面有多个表格(table) ，每个表格都定义出自己的默认政策与规则。表格是怎么组织的？每个表格的组成单位就是“chain”规则链，类似于表格中一行数据，每个规则链中定义了一些基本的规则类似于单元格，我们可以自定义规则链。Linux 的iptables 至少有三个表格，管理本机进出的filter 、管理后端主机的nat 、管理特殊旗标使用的mangle (较少使用) 。

1.1）filter：主要跟Linux 本机有关，这个是预设的过滤表，以下是其包含的规则链

INPUT：主要与封包想要进入我们Linux 本机有关；

OUTPUT：主要与我们Linux 本机所要送出的封包有关；

FORWARD：这个与Linux 本机比较没有关系，他可以封包『转递』到后端的计算机中，与nat 这个table 相关性很高。

1.2）nat：这个表格主要在用作来源与目的之IP 或port 的转换，与Linux 本机较无关，主要与Linux 主机后的局域网络内的计算机较有相关。以下是其包含的规则链

PREROUTING：在进行路由判断之前所要进行的规则(DNAT/REDIRECT)

POSTROUTING：在进行路由判断之后所要进行的规则(SNAT/MASQUERADE)

OUTPUT：与发送出去的封包有关

1.3）mangle：这个表格主要是与特殊的封包的路由旗标有关，早期仅有PREROUTING 及OUTPUT 链，不过从kernel 2.4.18 之后加入了INPUT 及FORWARD 链。由于这个表格与特殊旗标相关性较高，所以像较少使用mangle 这个表格。

表图

2）命令

这里简单介绍一些比较重要的命令，想知道所有的功能可以使用man查看该命令。

ü 对于规则链的操作

－F 清楚所有规则

iptables -t filter -F INPUT

－X 清除所有自定义规则

－L 列出当前所有规则

iptables -L INPUT -n --line-number -vvv

－A 在所选链的尾加一条规则

－N定义子链

不能与已有的链同名，自定义时，最好先清空所有规则

ü 定义规则的操作

-j 指定规则所做动作

ACCEPT 接受

DROP 丢弃别人可以判断你的系统使用防火墙

REJECT 弹回貌似根本没有打开这个端口

LOG 进行日志，/var/log/message

使用！号的时候需要在两端加空格表示取反

－p 进行协议进行匹配

［！］tcp｜udp｜icmp 协议列表以英文逗号为分隔符如tcp,udp 协议前加！号表示取反如－p ！tcp

根据端口进行匹配，必须指定协议必须是tcp|udp

--sport [!] port 包的源端口

--dport [!] port 包的目的端口

port 可以用/etc/services 中的协议名来代替不指定此项，则暗示所用端口，连续的端口 20：80表示从20到80所用端口包括20和80 ：20 0到20 80：从80到65535 ！20 非20端口

多端口匹配 -m multiport 如 iptables -A INPUT -p tcp -m multiport --sport 20,21,22,23,80 最多可以指定15的端口，以英文逗号分隔，没有空格，使用是必须指定协议

-i 以包进入本地所使用的网络接口来匹配

-i 参数指定网卡,适用于INPUT 和PREROUGING

-o 参数指定网卡,适用于OUTPUT 和POSTROUGING

-o 以包离开本地所使用的网络接口来匹配

另外重点介绍-－m参数

1) 基于状态的匹配－m state

NEW 初始包或源自于您的机器并要发送到目的IP的包都处于 NEW状态分为OUTPUT和INPUT NEW包

ESTABLISHED 一旦连接看到两个方向上都有通信流，与此附加相关的其它包都被看作处于ESTABLISHED 状态 NEW和ESTABLISHED 之间的区别很重要

RELATED 是那些启动新连接，但有与当前现有连接相关的包。RELATED状态可以用于调整组成多重连接协议（如ftp）的连接，以及与现有连接相关的错误包（如与现有连接相关的 ICMP 错误包）

INVALID 这种包不会被自动废弃；因此您需要插入适当的规则，并设置链策略，以便可以正确处理这些包。

允许主动发出的包iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

2) 基于MAC地址的匹配－m mac 仅对于PREROUTING和INPUT链起作用

如： iptables -A INPUT -p tcp --dport 23 -m mac --mac-source00:0C:29:BC:BBB -j REJECT

3) 基于封包数量的匹配－m limit

允许每秒通过一个icmp包，默认触发条件是5个

iptables -A INPUT -p icmp -m limit --limit 1/s -j ACCEPT

超过部分全部拒绝

iptables -A INPUT -p icmp -j DROP

4) 基于UID，GID的限制－m owner

iptables -A OUTPUT -p tcp --dport 23-m owner --uid-owner 500 -j REJECT

iptables -A OUTPUT -p tcp --dport 23 -m owner –gid-owner 500 -jREJECT

注意：-m owner 仅仅输出的封包有用，这个在droidwall开源项目中有使用到。

3.2 android iptables rules设计

droidwall根据上面的规则和命令，在filter表中自定义了4个规则链droidwall、droidwall-3g、droidwall-wifi、droidwall-reject。

3.2.1 droidwall

该规则链非常重要，它定义了不同的网口执行不同的规则链

1）规定与数据流量相关的网口的包执行droidwall-3g规则链

iptables -A droidwall -o rmnet+ -j droidwall-3g

iptables -A droidwall -o pdp+ -j droidwall-3g

iptables -A droidwall -o ppp+ -j droidwall-3g

iptables -A droidwall -o uwbr+ -j droidwall-3g

iptables -A droidwall -o wimax+ -j droidwall-3g

iptables -A droidwall -o vsnet+ -j droidwall-3g

iptables -A droidwall -o ccmni+ -j droidwall-3g

iptables -A droidwall -o usb+ -j droidwall-3g

2）规定与wifi相关网口的包执行droidwall-wifi规则链

iptables -A droidwall -o tiwlan+ -j droidwall-wifi

iptables -A droidwall -o wlan+ -j droidwall-wifi

iptables -A droidwall -o eth+ -j droidwall-wifi

iptables -A droidwall -o ra+ -j droidwall

韩半仙

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Android 网络防火墙的实现 Iptables解决方案

通过对Android SDK帮助文档的阅读，我没有发现Android的高层提供的API，于是通过更底层考虑，我发现了可以采用Iptables实现防火墙的功能。而且Linux下主流的防火墙也是Iptables。 Iptables的介绍：iptables 是与最新的 2.6.x 版本 Linux 内核集成的 IP 信息包过滤系统。如果 Linux 系统连接到因特网或 LAN、服务器
复制链接

扫一扫