精华内容
下载资源
问答
  • 2020-12-31 03:39:42

    安卓手机软件如何禁止联网?

    流量对WLAN没有影响—ios7有一个类似的选项,叫做“允许应用程序在后台刷新”,也就是说,它可以用来防止应用程序在后台运行(从网络获取内容)。为了在Android上实现类似的效果,需要像greenguard这样的工具。

    安卓手机怎么禁止软件自动联网?

    Android手机总是在应用程序刚安装后申请各种权限。为了方便起见,我们总是点击“确认”,这给了应用程序很多其他功能。这是一个应用程序,可以读取手机用户的联系方式、短信、地理位置等相关信息。修改权限的具体操作如下:

    1。打开手机设置,进入设置的常规页面。

    2。在应用程序管理中查找更多应用程序。

    3。进入应用管理界面后,点击权限(管理)。

    4。访问权限管理包括“自启动权限管理”、“应用权限管理”、“USB安装管理”。选择应用程序权限管理。

    5。找到WiFi on选项。

    6。单击关闭启用WiFi的应用程序,然后单击拒绝。

    如何禁止手机软件联网?

    不同的手机和Android版本可能有不同的设置。我使用华为glory 6和Android 4.4.2版。

    单击进入设置并选择“网络应用程序”。在这里,您可以管理单个应用程序或所有应用程序的网络。

    您可以禁用流量数据或WiFi网络。

    上下箭头指示交通数据。单击将其变为灰色以关闭。

    单击信号按钮将其变灰,以禁止应用WiFi网络。

    更多相关内容
  • 关于广告屏蔽,阿虚已经...其实很简单,方法就六个字:禁止软件联网 毕竟广告都是联网时,才会弹出 ● 1.1 举个栗子:超级课程表 最起初的超级课程表其实挺好:功能简单,实在,单纯的课程表,因为是最早一批做课程表的

    关于广告屏蔽,阿虚已经写过不少教程了:

    你可以通过装Google Play版程序、装广告屏蔽插件、可以通过安装旧版APP…等等方法来屏蔽广告

    但今天我想再说一个可能被很多人忽视的屏蔽广告的办法

    ▍1 提一下思路

    针对某些软件,比如词典、课程表、清单类软件、计算器…

    其实我们还有另外一种办法屏蔽广告

    阿虚说一提你可能就明白了

    其实很简单,方法就六个字:禁止软件联网

    毕竟广告都是联网时,才会弹出

    ● 1.1 举个栗子:超级课程表

    最起初的超级课程表其实挺好:功能简单,实在,单纯的课程表,因为是最早一批做课程表的APP,对于高校教务系统的导入也支持的最全

    可是后来,多出很多杂七杂八的功能:比如「下课聊」、「小纸条」??

    我只是很简单的想用一用最中间的那个「课程表」功能啊!!!

    由于下课聊、小纸条…这种社交功能的存在,里面自然少不了打广告的

    我便不敢开启通知栏提醒功能(课程提醒),否则就会收到的杂七杂八的广告弹窗了!

    ● 1.2 iOS

    由于阿虚用的 iPhone,这里简单说一下 iOS上怎么禁止软件联网

    先打开超级课程表APP » 登录APP » 导入教务系统课表

    然后你就可以把这个APP禁止联网了:打开 iOS 设置 » 找到超级课程表

    在超级课程表的软件设置里面,把无线数据「关闭」

    这样操作之后

    我依然能收到超级课程表的通知栏通知

    但是收不到它APP内每天更新的杂七杂八的广告

    因为打开APP不加载联网显示的内容,APP打开也不卡了

    ▍2 思路延伸

    禁止软件联网这个思路,适合于许多本地软件(无需联网就能使用)

    1. 不仅可以屏蔽广告,也能屏蔽升级。

    2. 不止在手机上,电脑上一样可以。

    除了手机上的:词典、计算器、清单类软件…

    某些电脑上的软件也可以用这个办法来屏蔽广告:压缩软件、截图软件、本地视频播放器、CDR(不禁止联网的话,会被在线防盗版检测)

    ● 2.1 安卓端禁止软件联网

    虽然安卓其实没必要用这个办法,毕竟安卓找安卓找去广告版APP其实很容易

    但大家还是可以学一学

    以小米手机演示说明一下,打开系统设置 » 更多应用 » 找到你想禁止联网的APP » 联网控制 » 关闭WLAN和数据

    ● 2.2 Windows端禁止软件联网

    方法1

    简单点的办法是用电脑管家一类的软件禁止软件联网

    这类软件很多,比如:腾讯电脑管家、360电脑管家、火绒等

    方法2

    办法2优于上面的方法1:通过系统自带的防火墙控制程序的联网功能。

    先再电脑左下角,打开控制面板

    再找到防火墙设置

    打开高级设置

    找到软件主程序

    比如:我要禁止按键精灵这款软件联网

    我们先来到它F盘下的安装目录,找到它的主程序:按键精灵2014.exe

    添加入站规则

    跟着下面的图一步一步操作就行了。

    选择程序

    添加程序exe的路径

    改为阻止连接

    何时运用这里全部勾选上

    名称什么的随便写就行

    最好的话,可以把出站规则也一并添加了

    而添加出站规则和添加入站规格是同样的步骤,阿虚就不重复演示了

    你会发现某些软件,联网对于它们来说根本就略显多余

    Merriam-Webster禁止联网后就是十分好用的词典

    nPlayer禁止联网后也成了极好用的本地播放器

    知道思路后,具体还是需要自己灵活使用

    展开全文
  • 禁止某个app联网

    千次阅读 2021-04-23 14:58:17
    //作者: 家 QQ203118908 //本来打算用iptables-restore用文件形式更新防火墙规则, //可是iptables-restore...禁止() app联网控制.允许() 声明 部分内容来自网络 bilibili 牙叔教程 微信公众号 牙叔教程 QQ群 747748653
    //作者: 家  QQ203118908
    
    
    //本来打算用iptables-restore用文件形式更新防火墙规则,
    //可是iptables-restore出现了bug,2013年就有人提过这个bug
    //https://linux.debian.bugs.dist.narkive.com/J0hbJiR6/bug-710379-xtables-addons-common-quota2-module-iptables-save-creates-invalid-record
    //又得改,坑爹
    
    //马丹,iptables -D INPUT -lineNumber也有BUG,
    //提示 index of deletion too big
    //日了够了
    //又得改,坑爹
    // sudo iptables -D OUTPUT 1 -t nat
    //
    // uid=`cat /data/system/packages.list | grep com.sohu.inputmethod.sogou | busybox awk '{print $2}'`
    // iptables -t filter -A OUTPUT -m owner --uid-owner=$uid -j DROP
    
    // 以上是android iptables 屏蔽某个app网络访问的内容,
    
    function 联网控制(appName) {
      // -A OUTPUT -m owner --uid-owner 10105 -j ACCEPT
      // -A OUTPUT -m owner --uid-owner 10105 -j DROP
      this.等待shell执行完毕的时间 = 0
      this.防火墙规则路径 = '/sdcard/iptables.txt'
      this.uid路径 = '/sdcard/' + appName + 'uidOwner.txt'
      this.appName = appName
      this.packageName = getPackageName(this.appName)
      this.执行shell = (cmd) => {
        var result = shell(cmd, true);
        console.show();
        log(result);
        if (result.code == 0) {
          toastLog("执行成功");
        } else {
          toastLog("执行失败!请到控制台查看错误信息");
        }
        sleep(this.等待shell执行完毕的时间)
      }
      this.uid = () => {
        var cmd = 'cat /data/system/packages.list | grep ' + this.packageName + ' > ' + this.uid路径
        log('cmd=', cmd)
        this.执行shell(cmd)
        // cat /data/system/packages.list | grep com.tencent.mobileqq > /sdcard/QQuidOwner.txt
        var 包含uid的文本 = files.read('/sdcard/' + appName + 'uidOwner.txt')
        log('包含uid的文本=', 包含uid的文本)
        var uidReg = new RegExp(this.packageName + '\\s*(\\d+)')
        log('uidReg=', uidReg)
        var uid = 包含uid的文本.match(uidReg)[1]
        log(uid)
        return uid
      }
      this.允许联网规则 = 'iptables -t filter -A OUTPUT -m owner --uid-owner ' + this.uid() + ' -j ACCEPT'
      this.禁止联网规则 = 'iptables -t filter -A OUTPUT -m owner --uid-owner ' + this.uid() + ' -j DROP'
      this.允许 = () => {
        this.清空该app的防火墙规则()
        this.将防火墙规则写入系统(this.允许联网规则)
      }
      this.禁止 = () => {
        this.清空该app的防火墙规则()
        this.将防火墙规则写入系统(this.禁止联网规则)
      }
    
      this.将防火墙规则写入系统 = (防火墙规则) => {
        var cmd = 防火墙规则
        this.执行shell(cmd)
      }
      this.导出防火墙规则 = () => {
        var cmd = 'iptables-save > ' + this.防火墙规则路径
        this.执行shell(cmd)
      }
      this.防火墙规则 = () => {
        this.导出防火墙规则()
        var 防火墙规则 = files.read(this.防火墙规则路径)
        log('防火墙规则=', 防火墙规则)
        return 防火墙规则
      }
      this.清空该app的防火墙规则 = () => {
        var 防火墙规则 = this.防火墙规则()
        // stringObject.replace(regexp/substr,replacement)
        // -A OUTPUT -m owner --uid-owner 10105 -j ACCEPT
        // -A OUTPUT -m owner --uid-owner 10105 -j ACCEPT
        // -A OUTPUT -m owner --uid-owner 10105 -j DROP
        // -A OUTPUT -m owner --uid-owner 10105 -j ACCEPT
        // -A OUTPUT -m owner --uid-owner 10105 -j ACCEPT
        // 删除之前添加的规则(iptables -A INPUT -s 192.168.1.5 -j DROP):
        // [root@test ~]# iptables -D INPUT -s 192.168.1.5 -j DROP
        // iptables -t filter -A OUTPUT -m owner --uid-owner=$uid -j DROP
        var 要删除的规则reg = new RegExp('-A (OUT|IN)PUT -m owner --uid-owner ' + this.uid() + ' -j (ACCEPT|DROP)', 'g')
        // 要删除的规则reg= /-A OUTPUT -m owner --uid-owner 10105 -j (ACCEPT|DROP)/
        // -A OUTPUT -m owner --uid-owner 10105 -j (ACCEPT|DROP)
        // iptables -D OUTPUT -m owner --uid-owner 10105 -j ACCEPT
        log('要删除的规则reg=', 要删除的规则reg)
        var new防火墙规则 = 防火墙规则.match(要删除的规则reg, '')
        log('new防火墙规则=', new防火墙规则)
        // new防火墙规则= [
        //   '-A OUTPUT -m owner --uid-owner 10105 -j ACCEPT',
        //   '-A OUTPUT -m owner --uid-owner 10105 -j DROP'
        //               ]
        if(new防火墙规则){
          for (let i = 0; i < new防火墙规则.length; i++) {
            var 规则 = new防火墙规则[i]
            规则 = 规则.replace('-A', '-D')
            var cmd = 'iptables ' + 规则
            this.执行shell(cmd)
          }
        }
        log('清空了指定app的防火墙规则')
      }
    }
    
    // var appName = 'QQ'
    // var appName = '哔哩哔哩'
    var appName = '微信'
    var app联网控制 = new 联网控制(appName)
    // app联网控制.禁止()
    app联网控制.允许()
    
    

    声明

    部分内容来自网络

    bilibili

    牙叔教程

    微信公众号 牙叔教程

    在这里插入图片描述

    QQ群

    747748653

    在这里插入图片描述

    展开全文
  • Android 通过adb禁止某个应用上网

    千次阅读 2021-02-27 23:11:30
    #通过包名查找应用的uid ...package name="com.xzh.hbls" codePath="/data/app/com.xzh.hbls-htP4fJSjJ2QQGmIifZ6xpA==" nativeLibraryPath="/data/app/com.xzh.hbls-htP4fJSjJ2QQGmIifZ6xpA==/lib" publicFl
    #通过包名查找应用的uid
    ➜  apk adb shell cat /data/system/packages.xml | grep com.xzh.hbls
        <package name="com.xzh.hbls" codePath="/data/app/com.xzh.hbls-htP4fJSjJ2QQGmIifZ6xpA==" nativeLibraryPath="/data/app/com.xzh.hbls-htP4fJSjJ2QQGmIifZ6xpA==/lib" publicFlags="940064324" privateFlags="0" ft="177e2c42790" it="177e2c434ca" ut="177e2c434ca" version="80" userId="10106">
    #关闭某个uid的上网权限
    ➜  apk adb shell iptables -I fw_OUTPUT -m owner --uid-owner 10106 -j DROP
    ➜  apk adb shell iptables -I fw_INPUT -m owner --uid-owner 10106 -j DROP
    

    注意命令行中的uid需要替换,uid如下图所示
    在这里插入图片描述
    详细信息请参考: https://blog.csdn.net/cyj88jyc/article/details/87985219

    为防止作者后期删除,copy一份:
    iptables是Linux的一个命令行工具,通过设置一些规则可以直接把指定uid或网址的数据包从ip层过滤掉,从而实现网络防火墙的功能,这部分已经比较成熟,android或厂商只是对iptables命令进行了封装,让android app可以通过iptables命令进行防火墙设置,iptables有很多复杂的功能,我们主要看看怎么设置白名单只让指定的uid app可以联网和设置黑名单让指定的uid app不能联网,我们通过代码流程来分析,代码是mtk android8.1。

    root后通过adb shell iptables -L可以查看当前的规则列表,Chain INPUT,OUTPUT就是控制数据包的输入输出,没做任何设置前应该张下面这个样子,Chain OUTPUT的数据包通过Chain fw_OUTPUT控制, Chain fw_OUTPUT的规则是空的,所以当前对网络不做限制。

    $ adb shell iptables -L
    Chain INPUT (policy ACCEPT)
    target prot opt source destination
    bw_INPUT all – anywhere anywhere
    fw_INPUT all – anywhere anywhere

    Chain FORWARD (policy ACCEPT)
    target prot opt source destination
    oem_fwd all – anywhere anywhere
    fw_FORWARD all – anywhere anywhere
    bw_FORWARD all – anywhere anywhere
    natctrl_FORWARD all – anywhere anywhere

    Chain OUTPUT (policy ACCEPT)
    target prot opt source destination
    oem_out all – anywhere anywhere
    firewall all – anywhere anywhere
    fw_OUTPUT all – anywhere anywhere
    st_OUTPUT all – anywhere anywhere
    bw_OUTPUT all – anywhere anywhere

    Chain fw_FORWARD (1 references)
    target prot opt source destination

    Chain fw_INPUT (1 references)
    target prot opt source destination

    Chain fw_OUTPUT (1 references)
    target prot opt source destination

    //android app层

    INetworkManagementService networkService = INetworkManagementService.Stub.asInterface(ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE));

    public void WhiteListMode(INetworkManagementService networkService) {
        FireWallUtils.setFirewallEnabled(networkService, true);//白名单模式
        FireWallUtils.setFirewallUidRule(networkService, 0, 1016, 0); //重置vpn uid rule
        FireWallUtils.setFirewallUidRule(networkService, 0, 1016, 1); //设置vpn uid为白名单
        FireWallUtils.setFirewallUidRule(networkService, 0, 0, 0); //重置root uid rule
        FireWallUtils.setFirewallUidRule(networkService, 0, 0, 1); //设置root uid为白名单
    

    // List whitelistApp = new ArrayList<>();
    // whitelistApp.add(“com.nuts.extremspeedup”);
    // PackageManager pm = mContext.getPackageManager();
    // for (String pkgName : whitelistApp) {
    // int uid = FireWallUtils.getUidFromPackageName(pm, pkgName);
    // if (uid > 0) {
    // FireWallUtils.setFirewallUidRule(networkService, 0, uid, 0); //重置 uid rule
    // FireWallUtils.setFirewallUidRule(networkService, 0, uid, 1); //设置白名单
    // }
    // }
    }

    public void BlackListMode(INetworkManagementService networkService) {
        FireWallUtils.setFirewallEnabled(networkService, false); //黑名单模式
        
          List<String> whitelistApp = new ArrayList<>();
          whitelistApp.add("com.iflytek.inputmethod");//com.iflytek.inputmethod
          PackageManager pm = getPackageManager();
            for (String pkgName : whitelistApp) {
                int uid = FireWallUtils.getUidFromPackageName(pm, pkgName); //获取app的uid
                if (uid > 0) {
                    FireWallUtils.setFirewallUidRule(networkService, 0, uid, 0); //重置 uid rule
                    FireWallUtils.setFirewallUidRule(networkService, 0, uid, 2); //设置uid为黑名单
                }
            }
    }
    
    public void DisableMobileMode(INetworkManagementService networkService) {
        FireWallUtils.setFirewallEnabled(networkService, false); //黑名单模式
        
          List<String> whitelistApp = new ArrayList<>();
          whitelistApp.add("com.iflytek.inputmethod");//com.iflytek.inputmethod
          PackageManager pm = getPackageManager();
            for (String pkgName : whitelistApp) {
                int uid = FireWallUtils.getUidFromPackageName(pm, pkgName);
                if (uid > 0) {
                    FireWallUtils.setFirewallUidChainRule(networkService, uid, 0, false); //(networkType == 1) ? WIFI : MOBILE; , 禁止此uid连mobile
                }
            }
    }
    

    import android.content.BroadcastReceiver;
    import android.content.ContentResolver;
    import android.content.Context;
    import android.content.Intent;
    import android.content.pm.ApplicationInfo;
    import android.content.pm.PackageManager;
    import android.os.INetworkManagementService;
    import android.os.Process;
    import android.os.RemoteException;
    import android.os.ServiceManager;
    import android.os.SystemProperties;
    import android.provider.Settings;
    import android.util.Log;

    import java.util.ArrayList;
    import java.util.List;

    public class FireWallUtils {
    private static final String TAG = “FireWallUtils”;

    public static void setFirewallEnabled(INetworkManagementService networkService, boolean enable) {
        try {
            networkService.setFirewallEnabled(enable);
        } catch (RemoteException e) {
            Log.e(TAG, "setFirewallEnabled RemoteException e:" + Log.getStackTraceString(e));
        } catch (Exception e) {
            Log.e(TAG, "setFirewallEnabled Exception e:" + Log.getStackTraceString(e));
        }
    }
    
    public static void setFirewallUidRule(INetworkManagementService networkService, int chain, int uid, int rule) {
        try {
            networkService.setFirewallUidRule(chain, uid, rule);
        } catch (RemoteException e) {
            Log.e(TAG, "setFirewallUidRule RemoteException e:" + Log.getStackTraceString(e));
        } catch (Exception e) {
            Log.e(TAG, "setFirewallUidRule Exception e:" + Log.getStackTraceString(e));
        }
    }
    
    public static int getUidFromPackageName(PackageManager pm, String pkgName) {
        try {
            ApplicationInfo appInfo = pm.getApplicationInfo(pkgName, PackageManager.MATCH_ALL);
            if (appInfo != null) {
                return appInfo.uid;
            }
        } catch (PackageManager.NameNotFoundException e) {
            //e.printStackTrace();
        }
        return -1;
    }
    

    }

    public static void setFirewallUidChainRule(INetworkManagementService networkService, int uid, int networkType, boolean allow) {
        try {
            networkService.setFirewallUidChainRule(uid, networkType, allow);
        } catch (RemoteException e) {
            Log.d(TAG, "setFirewallEnabled RemoteException e:" + Log.getStackTraceString(e));
        } catch (Exception e) {
            Log.d(TAG, "setFirewallEnabled Exception e:" + Log.getStackTraceString(e));
        }
    }
    public static void clearFirewallChain(INetworkManagementService networkService, String chain) {
        try {
            networkService.clearFirewallChain(chain);
        } catch (RemoteException e) {
            Log.d(TAG, "setFirewallEnabled RemoteException e:" + Log.getStackTraceString(e));
        } catch (Exception e) {
            Log.d(TAG, "setFirewallEnabled Exception e:" + Log.getStackTraceString(e));
        }
    }
    

    frameworks/base/core/java/android/os/INetworkManagementService.aidl

    void setFirewallEnabled(boolean enabled);
    boolean isFirewallEnabled();
    void setFirewallInterfaceRule(String iface, boolean allow);
    void setFirewallUidRule(int chain, int uid, int rule);
    void setFirewallUidRules(int chain, in int[] uids, in int[] rules);
    void setFirewallChainEnabled(int chain, boolean enable);
    
    /**
     * agold
     * Cnfigure firewall rule by uid and chain
     * @hide
     */
    void setFirewallUidChainRule(int uid, int networkType, boolean allow);
    
    /** @} */
    
    /**
     * agold
     * Delete all rules in  chain or all chains
     * @hide
     */
    void clearFirewallChain(String chain);
    

    frameworks/base/services/core/java/com/android/server/NetworkManagementService.java

    @Override
    public void setFirewallEnabled(boolean enabled) {
        enforceSystemUid();
        try {
            mConnector.execute("firewall", "enable", enabled ? "whitelist" : "blacklist");
            mFirewallEnabled = enabled;
        } catch (NativeDaemonConnectorException e) {
            throw e.rethrowAsParcelableException();
        }
    }
    
    @Override
    public void setFirewallUidRule(int chain, int uid, int rule) {
        enforceSystemUid();
        synchronized (mQuotaLock) {
            setFirewallUidRuleLocked(chain, uid, rule);
        }
    }
    
    private void setFirewallUidRuleLocked(int chain, int uid, int rule) {
        if (updateFirewallUidRuleLocked(chain, uid, rule)) {
            try {
                mConnector.execute("firewall", "set_uid_rule", getFirewallChainName(chain), uid,
                        getFirewallRuleName(chain, rule));
            } catch (NativeDaemonConnectorException e) {
                throw e.rethrowAsParcelableException();
            }
        }
    }
    
    /**
     * agold
     * @Configure firewall rule by uid and chain
     * @hide
     */
    public void setFirewallUidChainRule(int uid, int networkType, boolean allow) {
        android.util.Log.i("linyuan_NMS", "setFirewallUidChainRule uid = " + uid + ", networkType = " + networkType + ", allow = " + allow);
        //enforceSystemUid();
        final String MOBILE = "mobile";
        final String WIFI = "wifi";
    
        final String rule = allow ? "allow" : "deny";
        final String chain = (networkType == 1) ? WIFI : MOBILE;
    
        try {
            mConnector.execute("firewall", "set_uid_fw_rule", uid, chain, rule);
        } catch (NativeDaemonConnectorException e) {
            throw e.rethrowAsParcelableException();
        }
    }
    
    /**
     * agold
     * @Configure firewall rule by uid and chain
     * @hide
     */
    public void clearFirewallChain(String chain) {
        //enforceSystemUid();
        try {
            mConnector.execute("firewall", "clear_fw_chain", chain);
        } catch (NativeDaemonConnectorException e) {
            throw e.rethrowAsParcelableException();
        }
    }
    

    system/netd/server/CommandListener.cpp

    int CommandListener::FirewallCmd::runCommand(SocketClient *cli, int argc,
    char **argv) {
    if (argc < 2) {
    cli->sendMsg(ResponseCode::CommandSyntaxError, “Missing command”, false);
    return 0;
    }

    if (!strcmp(argv[1], "enable")) {
        if (argc != 3) {
            cli->sendMsg(ResponseCode::CommandSyntaxError,
                        "Usage: firewall enable <whitelist|blacklist>", false);
            return 0;
        }
        FirewallType firewallType = parseFirewallType(argv[2]);
    
        int res = gCtls->firewallCtrl.enableFirewall(firewallType);
        return sendGenericOkFail(cli, res);
    }
    if (!strcmp(argv[1], "disable")) {
        int res = gCtls->firewallCtrl.disableFirewall();
        return sendGenericOkFail(cli, res);
    }
    if (!strcmp(argv[1], "is_enabled")) {
        int res = gCtls->firewallCtrl.isFirewallEnabled();
        return sendGenericOkFail(cli, res);
    }
    
    if (!strcmp(argv[1], "set_uid_rule")) {
        if (argc != 5) {
            cli->sendMsg(ResponseCode::CommandSyntaxError,
                         "Usage: firewall set_uid_rule <dozable|standby|none> <1000> <allow|deny>",
                         false);
            return 0;
        }
    
        ChildChain childChain = parseChildChain(argv[2]);
        if (childChain == INVALID_CHAIN) {
            cli->sendMsg(ResponseCode::CommandSyntaxError,
                         "Invalid chain name. Valid names are: <dozable|standby|none>",
                         false);
            return 0;
        }
        int uid = atoi(argv[3]);
        FirewallRule rule = parseRule(argv[4]);
        int res = gCtls->firewallCtrl.setUidRule(childChain, uid, rule);
        return sendGenericOkFail(cli, res);
    }
    
    
    
    //agold start
    if (!strcmp(argv[1], "set_uid_fw_rule")) {
        ALOGD("set_uid_fw_rule");
        if (argc != 5) {
            cli->sendMsg(ResponseCode::CommandSyntaxError,
                         "Usage: firewall set_uid_fw_rule <uid> <mobile|wifi> <allow|deny>",
                         false);
            return 0;
        }
    
        int uid = atoi(argv[2]);
        FirewallChinaRule chain = parseChain(argv[3]);
        FirewallRule rule = parseRule(argv[4]);
    
        int res = gCtls->firewallCtrl.setUidFwRule(uid, chain, rule);
        return sendGenericOkFail(cli, res);
    }
    
    if (!strcmp(argv[1], "clear_fw_chain")) {
        if (argc != 3) {
            cli->sendMsg(ResponseCode::CommandSyntaxError,
                         "Usage: firewall clear_fw_chain <chain>",
                         false);
            return 0;
        }
    
        FirewallChinaRule chain = parseChain(argv[2]);
    
        int res = gCtls->firewallCtrl.clearFwChain(chain);
        return sendGenericOkFail(cli, res);
    }
    //agold end
    
    cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown command", false);
    return 0;
    

    }

    system/netd/server/FirewallController.cpp

    int FirewallController::enableFirewall(FirewallType ftype) {
    int res = 0;
    if (mFirewallType != ftype) {
    // flush any existing rules
    disableFirewall();

        if (ftype == WHITELIST) {
            // create default rule to drop all traffic
            std::string command =
                "*filter\n"
                "-A fw_INPUT -j DROP\n"
                "-A fw_OUTPUT -j REJECT\n"
                "-A fw_FORWARD -j REJECT\n"
                "COMMIT\n";
            res = execIptablesRestore(V4V6, command.c_str());
        }
    
        // Set this after calling disableFirewall(), since it defaults to WHITELIST there
        mFirewallType = ftype;
    }
    return res;
    

    }

    int FirewallController::disableFirewall(void) {
    mFirewallType = WHITELIST;
    mIfaceRules.clear();

    // flush any existing rules
    std::string command =
        "*filter\n"
        ":fw_INPUT -\n"
        ":fw_OUTPUT -\n"
        ":fw_FORWARD -\n"
        "COMMIT\n";
    
    return execIptablesRestore(V4V6, command.c_str());
    

    }

    int FirewallController::setUidRule(ChildChain chain, int uid, FirewallRule rule) {
    const char* op;
    const char* target;
    FirewallType firewallType = getFirewallType(chain);
    if (firewallType == WHITELIST) {
    target = “RETURN”;
    // When adding, insert RETURN rules at the front, before the catch-all DROP at the end.
    op = (rule == ALLOW)? “-I” : “-D”;
    } else { // BLACKLIST mode
    target = “DROP”;
    // When adding, append DROP rules at the end, after the RETURN rule that matches TCP RSTs.
    op = (rule == DENY)? “-A” : “-D”;
    }

    std::vector<std::string> chainNames;
    switch(chain) {
        case DOZABLE:
            chainNames = { LOCAL_DOZABLE };
            break;
        case STANDBY:
            chainNames = { LOCAL_STANDBY };
            break;
        case POWERSAVE:
            chainNames = { LOCAL_POWERSAVE };
            break;
        case NONE:
            chainNames = { LOCAL_INPUT, LOCAL_OUTPUT };
            break;
        default:
            ALOGW("Unknown child chain: %d", chain);
            return -1;
    }
    
    std::string command = "*filter\n";
    for (std::string chainName : chainNames) {
        StringAppendF(&command, "%s %s -m owner --uid-owner %d -j %s\n",
                      op, chainName.c_str(), uid, target);
    }
    StringAppendF(&command, "COMMIT\n");
    
    return execIptablesRestore(V4V6, command);
    

    }

    //agold start
    const char* FirewallController::FIREWALL = “firewall”;
    const char* FirewallController::FIREWALL_MOBILE = “mobile”;
    const char* FirewallController::FIREWALL_WIFI = “wifi”;
    //agold end

    int FirewallController::setupIptablesHooks(void) {
    int res = 0;
    //agold start
    std::string command = “*filter\n”;
    StringAppendF(&command, “-F firewall \n”);
    StringAppendF(&command, “-A firewall -o ppp+ -j mobile\n”);
    StringAppendF(&command, “-A firewall -o ccmni+ -j mobile\n”);
    StringAppendF(&command, “-A firewall -o ccemni+ -j mobile\n”);
    StringAppendF(&command, “-A firewall -o usb+ -j mobile\n”);
    StringAppendF(&command, “-A firewall -o cc2mni+ -j mobile\n”);
    StringAppendF(&command, “-A firewall -o wlan+ -j wifi\n”);
    StringAppendF(&command, “COMMIT\n”);
    res |= execIptablesRestore(V4V6, command.c_str());
    //agold end
    res |= createChain(LOCAL_DOZABLE, getFirewallType(DOZABLE));
    res |= createChain(LOCAL_STANDBY, getFirewallType(STANDBY));
    res |= createChain(LOCAL_POWERSAVE, getFirewallType(POWERSAVE));
    return res;
    }

    //agold start
    int FirewallController::setUidFwRule(int uid, FirewallChinaRule chain, FirewallRule rule) {
    ALOGD(“setUidFwRule”);
    std::string command = "filter\n";
    char uidStr[16];
    const char
    op;
    const char* fwChain;

    sprintf(uidStr, "%d", uid);
    
    if (rule == DENY) {
        op = "-I";
    } else {
        op = "-D";
    }
    
    if(chain == MOBILE) {
        fwChain = "mobile";
    }else{
        fwChain = "wifi";
    }
    

    /*
    if(chain == MOBILE) {
    if(rule == ALLOW)
    blacklistUsers.insert(uid);
    else
    blacklistUsers.erase(uid);
    }
    */

    ALOGD("setUidFwRule op = %s, chain = %s, uid = %s", op, fwChain, uidStr);
    StringAppendF(&command, "%s %s -m owner --uid-owner %s -j REJECT\n", op, fwChain, uidStr);
    StringAppendF(&command, "COMMIT\n");
    
    return execIptablesRestore(V4V6, command.c_str());
    

    }

    int FirewallController::clearFwChain(FirewallChinaRule chain) {
    std::string command = "filter\n";
    const char
    fwChain;
    if(chain == MOBILE) {
    fwChain = “mobile”;
    }else{
    fwChain = “wifi”;
    }
    StringAppendF(&command, “-F %s \n”, fwChain);
    StringAppendF(&command, “COMMIT\n”);
    return execIptablesRestore(V4V6, command.c_str());
    }
    //agold end

    运行到最后就是调用iptables命令去添加或删除一些规则,如果没有接口可以参考上面的接口增加,熟悉下iptables的规则就知道怎么添加了。

    WhiteListMode函数其实就调的下面的iptables命令

    adb shell iptables -A fw_INPUT -j DROP ; // -A表示要添加规则到fw_INPUT链, -j DROP表示添加丢弃规则,丢弃所有输入包
    adb shell iptables -A fw_OUTPUT -j REJECT // -A表示要添加规则到fw_OUTPU链, -j REJECT表示添加拒绝规则,拒绝所有输出包
    adb shell iptables -A fw_FORWARD -j REJECT

    adb shell iptables -I fw_OUTPUT -m owner --uid-owner 1016 -j ACCEPT // -I表示插入一条规则到fw_OUTPUT链,是一条白名单规则,允许uid 1016的数据包通过

    adb shell iptables -I fw_INPUT -m owner --uid-owner 1016 -j ACCEPT

    调用后iptables张下面这个样子,Chain OUTPUT的数据包通过Chain fw_OUTPUT控制, Chain fw_OUTPUT的规则是reject所有数据包,只允许uid 1016 vpn。

    $ adb shell iptables -L
    Chain INPUT (policy ACCEPT)
    target prot opt source destination
    bw_INPUT all – anywhere anywhere
    fw_INPUT all – anywhere anywhere

    Chain FORWARD (policy ACCEPT)
    target prot opt source destination
    oem_fwd all – anywhere anywhere
    fw_FORWARD all – anywhere anywhere
    bw_FORWARD all – anywhere anywhere
    natctrl_FORWARD all – anywhere anywhere

    Chain OUTPUT (policy ACCEPT)
    target prot opt source destination
    oem_out all – anywhere anywhere
    firewall all – anywhere anywhere
    fw_OUTPUT all – anywhere anywhere
    st_OUTPUT all – anywhere anywhere
    bw_OUTPUT all – anywhere anywhere

    Chain fw_FORWARD (1 references)
    target prot opt source destination
    REJECT all – anywhere anywhere reject-with icmp-port-unreachable

    Chain fw_INPUT (1 references)
    target prot opt source destination
    RETURN all – anywhere anywhere owner UID match vpn
    DROP all – anywhere anywhere

    Chain fw_OUTPUT (1 references)
    target prot opt source destination
    RETURN all – anywhere anywhere owner UID match vpn
    REJECT all – anywhere anywhere reject-with icmp-port-unreachable

    BlackListMode函数其实就调的下面的iptables命令

    adb shell iptables -F fw_INPUT

    adb shell iptables -F fw_OUTPUT //清除fw_OUTPUT链上所有规则,允许所有数据包通过

    adb shell iptables -D fw_INPUT -m owner --uid-owner 10086 -j DROP // -D表示删除一条规则

    adb shell iptables -I fw_OUTPUT -m owner --uid-owner 10086 -j DROP // -I表示插入一条规则到fw_OUTPUT链,是一条黑名单规则,只禁止uid 10086的数据包通过

    adb shell iptables -I fw_INPUT -m owner --uid-owner 10086 -j DROP

    调用后iptables张下面这个样子,Chain OUTPUT的数据包通过Chain fw_OUTPUT控制, Chain fw_OUTPUT的规则是只丢弃

    uid 为u11_a83(10086)的数据包,就是前面设置的app的uid 10086

    ~$adb shell iptables -L
    Chain INPUT (policy ACCEPT)
    target prot opt source destination
    bw_INPUT all – anywhere anywhere
    fw_INPUT all – anywhere anywhere

    Chain OUTPUT (policy ACCEPT)
    target prot opt source destination
    oem_out all – anywhere anywhere
    firewall all – anywhere anywhere
    fw_OUTPUT all – anywhere anywhere
    st_OUTPUT all – anywhere anywhere
    bw_OUTPUT all – anywhere anywhere

    Chain fw_INPUT (1 references)
    target prot opt source destination
    DROP all – anywhere anywhere owner UID match u11_a83

    Chain fw_OUTPUT (1 references)
    target prot opt source destination
    DROP all – anywhere anywhere owner UID match u11_a83

    如果需要单独控制wifi或移动数据,看DisableMobileMode里面setFirewallUidChainRule接口,这部分是厂商加的,如果没有可以按上面的内容进行添加,参考agold关键字,对照adb shell iptables -L的输出调试问题就不大了。

    调用后iptables张下面这个样子,Chain OUTPUT的数据包通过Chain fw_OUTPUT 和Chain firewall控制, Chain fw_OUTPUT的规则为空就是不限制,Chain firewall通过mobile和wifi链控制wifi/mobile, Chain wifi为空,Chain mobile为reject owner UID match u0_a79

    ~$ adb shell iptables -L
    Chain INPUT (policy ACCEPT)
    target prot opt source destination
    bw_INPUT all – anywhere anywhere
    fw_INPUT all – anywhere anywhere

    Chain OUTPUT (policy ACCEPT)
    target prot opt source destination
    oem_out all – anywhere anywhere
    firewall all – anywhere anywhere
    fw_OUTPUT all – anywhere anywhere
    st_OUTPUT all – anywhere anywhere
    bw_OUTPUT all – anywhere anywhere

    Chain firewall (1 references)
    target prot opt source destination
    mobile all – anywhere anywhere
    mobile all – anywhere anywhere
    mobile all – anywhere anywhere
    mobile all – anywhere anywhere
    mobile all – anywhere anywhere
    wifi all – anywhere anywhere

    Chain fw_INPUT (1 references)
    target prot opt source destination

    Chain fw_OUTPUT (1 references)
    target prot opt source destination

    Chain mobile (5 references)
    target prot opt source destination
    REJECT all – anywhere anywhere owner UID match u0_a79 reject-with icmp-port-unreachable

    Chain wifi (1 references)
    target prot opt source destination

    iptables命令可以参考 https://blog.csdn.net/l1028386804/article/details/47356011

    https://blog.csdn.net/reyleon/article/details/12976341

    ————————————————
    版权声明:本文为CSDN博主「cyj88jyc」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/cyj88jyc/article/details/87985219

    展开全文
  • // 检测网络 public static boolean checkNetworkAvailable(Context context) { ConnectivityManager connectivity = (ConnectivityManager) context .getSystemService(Context.CONNECTIVITY_SERVICE);...
  • 但同时我们应该意识到手机内安装的APP并不都是向善的,由于各方面原因,往往需要我们开通足够的权限才能正常运行,而这些权限的开启很可能泄露我们的隐私,尤其在安卓手机鱼龙混杂的应用市场。针对这一情况,安卓...
  • 通过ADB启用和禁用系统应用

    千次阅读 2021-03-18 12:58:15
    无论该应用程序是系统应用程序还是第三方应用程序(已安装用户),它都应该起作用。请参阅“ 确定应用程序的程序包名称”以获取相关应用程序的程序包名称,并使用adb shell执行...适用于Android Lollipop及更高版本...
  • android应用上网屏蔽

    千次阅读 2018-12-03 12:54:47
    Android 4.3 为了实现当个应用的上网控制,需要为Setting应用添加控制接口。 先说下原理,使用iptables控制应用uid访问网络,iptables命令的执行必须是root权限,也就是说不能在systemserver相关的系统服务中直接...
  • 原理类似电脑ping命令 public static boolean isNetworkOnline() { Runtime runtime = Runtime.getRuntime(); Process ipProcess = null; try { ipProcess = runtime.exec("ping -c 5 -w 4 223.5.5.5");...
  • Android模拟器默认的地址是10.0.2.3,默认的DNS也是10.0.2.3,对于在家里上网学习Android的人来讲,一般电脑的IP都是192.168.1.100之类的,不在同一个网段。所以就会出现电脑可以上网但是模拟器不能上网的情况。其实...
  • 3.如何在Android系统中集成? 以上通过adb shell命令行在Android设备上将方案调通之后,接下来考虑如何集成在Android系统中。作为一个整体解决方案,需要至少解决两部分功能: (1)网络访问规则。包括规则定义、...
  • MIUI可以说是相对Android原生改进较大的一款ROM,特别是在V5之后,做了很多实用的功能。但有些改进在方便用户的同时也给用户带来了一些困扰。最近收到不少朋友反馈在最新的MIUI系统下安装《驱家新闻》客户端后,出现...
  • 因为Android8.1base/core/java/android/os/INetworkManagementService.aidl中的 void setFirewallUidChainRule(int uid, int networkType, boolean allow);被删除了,实在是一筹莫展。 现在想问一下8.1除此之外还有...
  • I'm looking for an adb shell command to enable/disable mobile ... The app is only being tested on rooted devices so I have adb root privileges. I looked around and found that wifi can be enabled/dis...
  • 面向移动终端的操作系统有:Symbian、PalmOS、Windows Phone、Linux、Android和iOS等,其中被广泛使用的是Android和iOS Symbian 塞班系统(Symbian系统)是塞班公司为手机而设计的操作系统,它的前身是英国宝意昂...
  • 有些时候安卓里面装的app锁屏的时候会自动掉线。当然了一般qq微信哪些不会有太大问题。但如果你有用一些国外的通讯软件或者经常开ssr之类的软件,很容易就会遇到。排除掉有些国内rom定制之后特意杀死某些app之外。...
  • Android 禁止应用在模拟器上运行

    万次阅读 2018-12-27 11:08:44
    一种禁止应用在模拟器上运行的思路,首先要分辨出模拟器和真机,然后对模拟器的做处理。 方法1:  检测点:电池电量和温度(模拟器的电池伏数可以为0或者是1000,而温度一定是0。但是真机的是可变的) public ...
  • 首先我们要弄明白,防火墙将怎么对待 这些数据包。这些数据包会经过一些相应的规则链,比如要进入你的计算机的数据包会首先进入INPUT链,从我们的计算机发出的数据包会经过 OUTPUT链,如果一台计算机做一个网络的...
  • Android 6.0 Doze模式请求禁止联网

    千次阅读 2017-03-05 11:08:34
    Android 6.0(API level 23)开始,当手机没有连接到电源,设备进入Doze模式时,系统将通过延迟最近用户没有使用的应用程序的后台CPU运作及网络活动,让应用程序处于App Standby状态,以此来减少电池消耗。...
  • 一个简单的登录功能作为Android APP 项目 与springBoot的对接演示 账号为Allen 密码为123 若账号密码均正确自动跳转到主页面 若账户信息错误则显示 “账户信息错误” 停留在当前页面不跳转 springBoot 作为Android ...
  • Android手机最让人不放心的是什么?没错,就是各种存在“潜规则”的APP。...相信各位童鞋都知道,每一款Android手机都会预装(自带)无数的APP,其中有一些可以卸载,有一些则无法卸载。问题来了,出于某些商业...
  • adb命令禁用&启用APP及日常adb命令

    千次阅读 2021-07-17 15:26:07
    1、禁用APP adb shell pm disable-user '包名' 2、启动APP adb shell pm enable '包名'
  • 大家好,我们这一节讲一下,Android获取Ip的一些方法,在我们开发中,有判断手机是否联网,或者想获得当前手机的Ip地址,当然WIFI连接的和我们3G卡的Ip地址当然是不一样的.首先我尝试了如下方法:[java]...
  • Android App 链式唤醒分析

    千次阅读 2020-07-17 08:20:00
    Gracker | 作者承香墨影 | 校对https://androidperformance.com/2020/05/07/Android-App-Chain-Wakeup/| 原文...
  • uniapp之安卓APP权限说明

    千次阅读 2021-08-24 15:33:47
    android.permission.INTERNET 允许程序访问网络连接,可能产生GPRS流量 android.permission.WRITE_EXTERNAL_STORAGE 允许程序写入外部存储,如SD卡上写文件 android.permission.READ_PHONE_STATE 允许程序访问电话...
  • 流量控(手机流量统计)app,为你带来准确,及时的流量通知,帮助用户时刻查询自己的手机流量和使用状况,管理程序的流量使用,全方面保证您的流量使用流量控(手机流量统计)app介绍流量控是一款统计安卓手机使用流量的...
  • android iptables 屏蔽某个app网络访问

    千次阅读 2015-07-31 10:00:43
    uid=`cat /data/system/packages.list | grep com.sohu.inputmethod.sogou | busybox awk '{print $2}'` iptables -t filter -A OUTPUT -m owner --uid-owner=$uid -j DROP
  • 相信很多使用安卓手机的用户最讨厌手机出厂时自带的系统软件,对于这些不常用、占内存、耗流量的软件很多安卓用户...【初级解决法】初级解决方法的方案就是通过手机自带的权限管理功能禁止手机自带软件、APP、流氓软...
  • 前言:为保证用户数据和设备的安全,Google针对下一代 Android 系统(Android P) 的应用程序,将要求默认使用加密连接,这意味着 Android P 将禁止 App 使用所有未加密的连接,因此运行 Android P 系统的安卓设备无论...
  • droidwall.apk

    2021-02-26 16:30:34
    设置Android防火墙,对一个或多个APP或系统进程设置防火墙,禁止联网或允许联网

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,336
精华内容 534
关键字:

安卓禁止app联网

友情链接: VGA.rar