精华内容
下载资源
问答
  • 信息安全机制是网络视频监控系统安全体系中的核心部分,其安全性包括业务数据安全性和音视频媒体数据安全性,对此,业界有多种解决方案和算法标准,选择了监控业界两个代表性网络视频监控标准的信息安全机制进行解读...
  • 信息安全机制作业

    2019-09-27 21:54:33
    信息安全 信息安全基本属性有哪些? 保密性-信息不被泄露给未经授权方 (信息的加密传递) 完整性-信息在存储和传输过程中未经授权不能改变 (银行的记录尤其需要注意完整性和不可否认性) 不可否认性-所有参与者都不...

    信息安全

    1. 信息安全基本属性有哪些?

      • 保密性-信息不被泄露给未经授权方 (信息的加密传递)
      • 完整性-信息在存储和传输过程中未经授权不能改变 (银行的记录尤其需要注意完整性和不可否认性)
      • 不可否认性-所有参与者都不可能否认或抵赖曾经完成的操作和承诺 (在电子商务、银行等尤其需要重视)
      • 可用性-信息可被授权者访问并按需使用
      • 可控性-对信息的传播及内容具有控制能力 (控制舆论等)

      其中,保密性、完整性、不可否认性是最基本的三大属性。

    2. 安全服务与安全机制的关系是什么?

      安全机制是安全服务的基础,必须具有安全的机制,才可能有可靠地安全服务。一种安全服务的实施可以单独使用或组合使用不同的安全机制,取决于该服务的目的以及使用的机制。服务是接口,机制是保证,实现在层次 。

    在这里插入图片描述
    3. OSI信息安全体系中的安全服务哪些?

    ​ 认证服务、访问控制服务、数据机密性服务、数据完整性服务、不可否认性服务

    1. 数据保密性服务(举一反三:其他服务)可以通过哪些机制来实现?
    • 数据保密性服务由加密机制、业务流填充机制、路由控制机制共同完成。(业务流填充机制是一种数据流的加密机制,用来保障业务数据的安全)
    • 认证服务需要加密机制、数字签名机制、鉴别交换机制共同完成(加密机制和数字签名机制均为通过密码或者数字签名的方式进行安全认证,鉴别交换机制是以信息交换的方式来确认实体身份的机制)
    • 访问控制服务由访问控制机制控制,主要完成对不同用户授权不同权限的操作
    • 完整新服务由加密机制、数字签名机制、数据完整性机制共同完成。主要为认证访问数据者的信息,不能让信息被未授权者随意修改。
    • 抗抵赖服务由数字签名机制、完整性机制和公证机制共同完成。
    1. 叙述P2DR2模型的含义?

    P2DR2是PDR模型的发展,包括五方面:

    • 安全策略(Policy):定义系统的监控周期、确立系统恢复机制、制定网络访问控制策略和明确系统的总体安全规划和原则
    • 安全保护(Protect):可抵抗大多数入侵事件的发生。身份认证、访问控制、防病毒、防火墙、VPN等
    • 入侵检测(Detection):漏洞扫描、入侵检测、安全审计
    • 安全响应(Reaction):漏洞修补、报警、中止服务等
    • 安全恢复(Recovery):在多种备份机制的基础上,启用应急响应恢复机制实现系统的瞬时还原;进行现场恢复及攻击行为的再现,供研究和取证
    展开全文
  • 综合采用公密钥加密、分组加密、数字签名等数据加密技术,提出了一种有效解决基于GPRS通信的嵌入式应用系统中数据通信安全问题的机制。通过实例验证,可以有效防范伪造、窜改、重发等常见的恶意攻击。
  • Android系统信息安全机制

    千次阅读 多人点赞 2019-02-16 09:50:20
    今天和大家分享一下—Android系统信息安全机制–1、安卓系统信息的获取/********************设备配置信息相关********************//** *主板 */ publicstaticfinalStringBUILD_BOARD=Build.B

    双十一快要来临了,安卓三个版本已近更新完毕,打包上线,所以最近在疯狂的写博客、欢迎大家前来讨论问题,互相学习o!!!
    今天和大家分享一下—Android系统信息与安全机制–
    #1、安卓系统信息的获取

    /********************设备配置信息相关********************/
    
    /**
    *主板
    */
    publicstaticfinalStringBUILD_BOARD=Build.BOARD;
    
    /**
    *系统定制商
    */
    publicstaticfinalStringBUILD_BRAND=Build.BRAND;
    
    /**
    *设备参数
    */
    publicstaticfinalStringBUILD_DEVICE=Build.DEVICE;
    
    /**
    *显示屏参数
    */
    publicstaticfinalStringBUILD_DISPLAY=Build.DISPLAY;
    
    /**
    *唯一编号
    */
    publicstaticfinalStringBUILD_FINGERPRINT=Build.FINGERPRINT;
    
    /**
    *硬件序列号
    */
    publicstaticfinalStringBUILD_SERIAL=Build.SERIAL;
    
    /**
    *修订版本列表
    */
    publicstaticfinalStringBUILD_ID=Build.ID;
    
    /**
    *硬件制造商
    */
    publicstaticfinalStringBUILD_MANUFACTURER=Build.MANUFACTURER;
    
    /**
    *版本
    */
    publicstaticfinalStringBUILD_MODEL=Build.MODEL;
    
    /**
    *硬件名
    */
    publicstaticfinalStringBUILD_HARDWARE=Build.HARDWARE;
    
    /**
    *手机产品名
    */
    publicstaticfinalStringBUILD_PRODUCT=Build.PRODUCT;
    
    /**
    *描述build的标签
    */
    publicstaticfinalStringBUILD_TAGS=Build.TAGS;
    
    /**
    *Builder类型
    */
    publicstaticfinalStringBUILD_TYPE=Build.TYPE;
    
    /**
    *当前开发代号
    */
    publicstaticfinalStringBUILD_VERSION_CODENAME=Build.VERSION.CODENAME;
    
    /**
    *版本号
    */
    publicstaticfinalintBUILD_VERSION_SDK_INT=Build.VERSION.SDK_INT;
    
    /**
    *编译时间
    */
    publicstaticfinallongBUILD_TIME=Build.TIME;
    
    /**
    *User名
    */
    publicstaticfinalStringBUILD_USER=Build.USER;
    
    /**
    *host值
    */
    publicstaticfinalStringBUILD_HOST=Build.HOST;
    

    #2.PackageManager的使用
    PackageManager是安卓提供的来负责所有安装的APP;
    这些封装信息就像我们自己封装的bean一样,用老封装程序的相关信息。
    下面列举一下常用的封装信息:

     /**
         * 根据传入类型获取设备上安装的app信息
         * flag :1 ------全部应用
         * flag :2 ------系统应用
         * flag :3 ------第三方应用
         * flag :4 ------SD卡应用
         * @param flag
         * @param context
         * @return
         */
        public static List<PMAppInfo> getAppInfo(int flag,Context context){
            //获取packageManager对象
            PackageManager pm = context.getPackageManager();
            //获取应用信息
            List<ApplicationInfo> listAppcations =pm.getInstalledApplications(PackageManager.GET_URI_PERMISSION_PATTERNS);
            List<PMAppInfo> appInfos = new ArrayList<PMAppInfo>();
            //判断应用类型
            switch (flag){
                case 1:  //全部应用
    
                    appInfos.clear();
    
                    for(ApplicationInfo app : listAppcations){
                        appInfos.add(makeAppInfo(app,pm));
                    }
    
                    break;
    
                case 2:  //系统应用
                    appInfos.clear();
    
                    for(ApplicationInfo app : listAppcations){
                        if((app.flags & ApplicationInfo.FLAG_SYSTEM)!= 0){
                            appInfos.add(makeAppInfo(app,pm));
                        }
                        appInfos.add(makeAppInfo(app,pm));
                    }
    
                    break;
                case 3:  //第三方APP
                    appInfos.clear();
    
                    for(ApplicationInfo app : listAppcations){
                        if((app.flags & ApplicationInfo.FLAG_SYSTEM) <= 0){
                            appInfos.add(makeAppInfo(app,pm));
                        }else if((app.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0){
                            appInfos.add(makeAppInfo(app,pm));
                        }
                    }
                    break;
                case 4:  //SD卡APP
                    appInfos.clear();
    
                    for(ApplicationInfo app : listAppcations){
                        if((app.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE)!= 0){
                            appInfos.add(makeAppInfo(app,pm));
                        }
                        appInfos.add(makeAppInfo(app,pm));
                    }
    
                    break;
    
                default:
                    return null;
    
            }
            return appInfos;
        }
        private static PMAppInfo makeAppInfo(ApplicationInfo app,PackageManager pm){
            PMAppInfo pmAppInfo = new PMAppInfo();
            pmAppInfo.setAppLabel((String) app.loadLabel(pm));
            pmAppInfo.setAppIcon(app.loadIcon(pm));
            pmAppInfo.setPkgName(app.packageName);
            return pmAppInfo;
        }
    

    #3.ActivityManager的使用
    前面使用PackageManger获得了所有的应用包信息,下面介绍ActivityManager。
    PackageManger重点在于获得应用的包信息,而ActivityManager重点在获得运行的应用程序信息。
    同PackageManger一样,ActivityManager也封装了不少Bean对象,如:
    (1)内存信息----ActivityManager.MemoryInfo
    MemoryInfo有几个非常重要的字段:avaiMem–系统可用内存,totalMem–总内存,threshold–低内存的阈值(即区分低内存的临界值),lowMemory–是否处于低内存

    (2)Debug.MemoryInfo获取当前进程下的内存信息
    而ActivityManager.MemoryInfo是全局的内存信息
    (3)运行进程的信息----RunningAppProcess
    存储进程相关的信息,如:
    processName–进程名,pid–进程pid,uid–进程uid,pkgList–该进程下的所有包。
    (4)运行的服务信息
    它里面包含一些服务进程的信息,如:
    activitySince–第一次被激活的时间、方式,foreground–服务是否在后台执行

    接下来通过例子来看一下:

    /**
         * 通过ActivityManager获取当前进程的相关信息
         * @param context
         * @return
         */
        public static List<com.puzzle.libin.utils_library.bean.AMProcessInfo> getRunningProcessInfo(Context context){
            ArrayList<AMProcessInfo> amProcessInfosList = new ArrayList<>();
    
            ActivityManager manager = (ActivityManager)context.getSystemService(context.ACTIVITY_SERVICE);
    
            List<ActivityManager.RunningAppProcessInfo> appProcessesList = manager.getRunningAppProcesses();
    
            for (int i = 0 ; i<appProcessesList.size();i++){
                ActivityManager.RunningAppProcessInfo info = appProcessesList.get(i);
    
                int pid = info.pid;
                int uid = info.uid;
                String processName = info.processName;
                int[] memoryPid = new int[]{pid};
                Debug.MemoryInfo[] processMemoryInfo = manager.getProcessMemoryInfo(memoryPid);
    
                int memorySize = processMemoryInfo[0].getTotalPss();
    
                AMProcessInfo amProcessInfo = new AMProcessInfo();
                amProcessInfo.setPid(pid+"");
                amProcessInfo.setUid(uid+"");
                amProcessInfo.setMemorySize(memorySize+"");
                amProcessInfo.setProcessName(processName);
    
                amProcessInfosList.add(amProcessInfo);
            }
            return amProcessInfosList;
        }
    

    #4.Android安全机制
    安全不管在哪个平台都非常重要,首先介绍一下Android系统五道防线:
    第一道防线:
    代码安全机制----代码混淆proguard
    即使编译成apk也可以被反编译,所以混淆关键diamante、替换命名可以破坏阅读难度
    第二道防线:
    应用接入权限----AndroidMainfest文件权限声明,权限检查机制
    这个防线天生有问题:被授予的权限无法停止;在应用声明APP使用权限时,用户无法针对部分权限限制;权限的声明机制与用户安全理念相关;
    Android系统会通过以下
    首先,先判断permission名称,如果为空返回PERMISSION_DENIED;
    其次,判断uid,为0则为root权限,不限制权限,如果如System Server则为系统服务,不限制权限,如果返回uid与请求的uid不同,则返回PERMISSION_DENIED;
    最后,通过PackageManagerServer.checkUidPermission()方法判断该权限,会先去XML权限表和系统级platform.xml中进行查找。
    第三道防线:
    应用签名机制----数字证书
    只有相同的数字签名的App在升级的时候才会被认为是同一个,而且没有签名的APP是无法发布到应用市场的,而且数字证书的时间是需要自己设置的,一般设置20年,曾有人设置一年结果把自己坑了。
    第四道防线:
    Linux内核安全机制----Uid、访问权限控制
    Android继承了Linux,所以安全机制也继承过来了,通常情况下只有system、root用户才能访问到系统文件,一般用户无法访问
    第五道防线:
    安卓虚拟机沙箱机制----沙箱隔离
    安卓的APP是运行在虚拟机中的,所有才有了沙箱机制,每个app都有一个与之对应的uid,每个app也运行在单独的app中,所以一个应用崩溃也不会导致其他应用奔溃。

    扫码关注公众号“伟大程序猿的诞生“,更多干货新鲜文章等着你~

    公众号回复“资料获取”,获取更多干货哦~

    有问题添加本人微信号“fenghuokeji996” 或扫描博客导航栏本人二维码

    展开全文
  •  随着3G应用的快速发展,移动通信系统的...本文研究了第三代移动通信系统的信息安全机制, 包括第三代移动通信系统面临的信息安全威胁等。在此基础上对以3G智能手机为代表的移动终端的安全使用提出了一些方法。
  • 摘要硬件软件和数据等这些组成计算机信息系统的部分受到相应的保护不会因为恶意的破坏泄露重要的隐私这就是计算机信息系统的安全性这种安全性能够为系统的正常运行提供保障但是当前在计算机信息系统安全机制的建立中...
  • 安全机制

    千次阅读 2016-07-20 00:10:41
    安全机制包括两个不同的部分,第一是网页的安全,包括但是不限于网页数据安全传输、跨域访问、用户数据安全等,第二部分是游览器的安全,具体是指网页或者JavaScript代码有一些安全问题或者存在安全漏洞,游览器也...

    安全机制包括两个不同的部分,第一是网页的安全,包括但是不限于网页数据安全传输、跨域访问、用户数据安全等,第二部分是游览器的安全,具体是指网页或者JavaScript代码有一些安全问题或者存在安全漏洞,游览器也能够在运行它们的时候保证自身的安全,不受攻击从而泄漏数据或者使系统破坏

    网页安全模型

    安全模型基础

    当用户访问网页的时候,游览器需要确保该网页中数据的安全性,如Cookie、用户名和密码等信息不会被其他的恶意网页所获取。

    它表示的是网页所在的域名、传输协议和端口等信息,域是表明网页身份的重要标识,如网页“http://blog.csdn.net/steward2011”,它的域是”http://blog.csdn.net“,其中”http:”是协议,”blog.csdn.net”是域名,而端口默认为80,用户可以打开chrome游览器的开发者工具和控制台,输入”window.location”查看域的各种信息。根据安全模型的定义,不同域中网页间的资源访问是收到严格限制的,也就是网页的DOM对象、个人数据、XMLHttpRequest等需要收到控制,默认情况下,不同网页间的这些数据是被游览器隔离的,不能互相访问,这是HTML的“Same origin Policy”策略。

    XSS

    XSS全称Cross Site Scripting,其含义是执行跨域的JavaScript脚本代码,执行脚本本身没什么问题,但由于执行其他域的脚本代码可能存在严重的危害,还有可能会盗取当前域中的各种数据,因此HTML5规范之前,跨域的资源共享是不被允许的,这样做会造成功能上的缺陷,为此标准组织和WebKit使用了大量的技术来避免各种攻击的发生,例如在HTTP消息头中定义了一个名为“X-XSS_Protection”的字段,此时游览器会打开防止XSS攻击的过滤器,目前主要的游览器都支持该技术。

    CSP

    Content Security Policy是一种防止XSS攻击的技术,它使用HTTP消息头来指定网站能够标注哪些域中的哪些类型的资源被允许加载在该域的网页中,包括JavaScript、CSS、HTML Frames、字体、图片和嵌入对象(如插件、Java Applet等),在HTTP消息头中,可以使用相应的字段来控制这些域和资源的访问,其主要是服务器返回的HTTP消息头,目前不同游览器中使用不同的字段名来表示,主要包含三种名称:Content-Security-Policy(由标准组织定义)、X-WebKit-CSP(实验性的字段名)和X-Content-Security-Policy(Firefox使用),该字段的定义格式如下(字段名:指令名 指令值;指令名 指令值;….. )。下表是包含一个字段名及一系列的“指令名+指令值”对的列表,其包括11种类型的指令来控制网页中的各种资源和安全行为:

    指令名 含义
    default-src 控制所有的资源,如果已经包含该指定资源的指令,那么default-src优先级较低,如果没有包含该知道的指令,那么使用default-src指令定义的内容
    script-src 用于控制JavaScript代码
    stype-src 用于控制CSS样式表
    img-src 用于控制图片资源
    connect-src 用于控制XMLHttpRequest、WebSocket等同连接相关
    font-src 用于控制字体资源
    object-src 用于控制“embed”、“object”、“applet”等元素加载的资源
    media-src 用于控制多媒体资源,包括音频和视频
    frame-src 用于控制可以加载的框
    sandbox 用于控制网页中是否允许弹出对话框,插件和脚本的执行等,值可能是”allow-forms”、”allow-same-origin”、”allow-script”、”allow-to-navigation”
    report-uri 将错误消息发送到指定的URI
    CORS

    根据“Same Origin Policy”原则,游览器做了很多的限制以组织跨域的访问,所以跨域的资源共享又变成了一个问题,标准组织为了适应现实的需要,zhi’ding 额CORS(Cross Origin Resource Sharing)规范,也就是跨域资源共享,该规范借助域HTTP消息头并通过定义一些字段来实现,主要是定义不同域之间交互数据的方式,当某个网页希望访问其他域资源的时候,需要按照CORS定义的标准从一个域访问另外一个域的数据。CORS使用HTTP头来描述规范定义的内容,HTTP消息头是指包含有限个字段(如Accept、Accept-language等)并请求类型只是HEAD、GET和POST。通常简单的HTTP消息头只需要较小的代价,而包含了CORS的消息头却不是简单的HTTP消息头,该消息请求在CORS里面被称为“Preflight”消息请求,CORS使用到的字段如下表:

    字段名 类型 含义
    Origin 请求端 请求端申明该请求来源于哪个域
    Access-Control-Request-Method 请求端 请求端的HTTP请求类型,如PUT、GET、HEAD等
    Access-Control-Request-Headers 请求端 一个以“,”为分隔符的列表,表项是自定义请求的字段
    Access-Control-Allow-Origin 响应端 表明响应端允许的域,可以指定特定的域,也可以使用“*”表示允许所有的域请求
    Access-Control-Allow-Credentials 响应端 默认情况Cookie之类的信息是不能共享的,但如果设置该字段为真,那么Cookit是可以传输给请求端的
    Access-Control-Expose-Headers 响应端 是否暴露回复消息给XHR,以便XHR能够读取响应消息的内容
    Access-Control-Max-Age 响应端 Prelight请求的有效时间
    Access-Control-Allow-Methods 响应端 响应端 允许的HTTP请求类型,如前面的PUT、GET、HEAD等
    Access-Control-Allow-Headers 响应端 响应端支持的自定义字段

    其类型可以分成请求段和相应端,如果每个HTTP消息头都要包含这些字段那是一种浪费,因为没有必要每个HTTP消息头都重复包含这些类型,为了就会使用到“Preflight”请求来发送包含CORS字段的消息,而其他则是简单的HTTP消息头,表中Access-Control-Max-Age表示Prefight请求的有效期,在有效期内不需要重复发送CORS定义字段的消息,CORS和CSP的区别在于CSP定义的是网页自身能够访问的某些域和资源,而CORS定义的是一个网页如何才能访问被同源策略禁止的跨域资源,规定了两者交互的协议和方式。

    Cross Document Messaging

    Cross Document Messaging定义的是通过window.postMessage接口让JavaScript在不同域的文档中传递消息成为可能,以下代码演示了如何使用该技术来传递消息:

    http://csdn.com中JavaScript代码
    contentWin.postMessage('Hello','http://blog.csdn.net');
    
    http://blog.csdn.net/steward网页中的JavaScript代码
    window.addEventListener('message',function receiver(e)) {
      if (e.origin == 'http://myweb.com') {
        if (e.data == 'Hello') {
          e.source.postMessage('Hello2', e.origin);
        } else {
          alert(e.data);
        }
      }
    }, false);

    该机制使用“window”对象的postMessage方法来传递给其他域网页消息,该方法包含两个参数,第一个是消息内容,第二个是需要对方的域消息,而在接收方,开发者在JavaScript代码中注册一个消息响应函数,如果检测出消息来源于上述“http://csdn.com”,那么就回复一个“Hello2”的消息。

    安全传输协议

    对于用户而言,网页的安全还包含一个重要点,就是用户和服务器之间交互数据的安全性问题,对于一般的网页而言,这些数据的传输都是使用明文方式,也就是说它们对谁都是可见的,这能够满足大多数的使用情况,但是对于隐私的数据,如密码、银行帐号等,如果使用明文来传输就存在风险,为此Web引入了安全的数据传输协议HTTPS,HTTPS是在HTTP协议之上使用SSL(Secure Socket Layer)技术来对传输的数据进行加密,从而保证了数据的安全性,SSL协议是构建在TCP协议之上、应用层协议HTTP之下的,SSL工作的主要流程是先进行服务器认证,然后是用户认证,SSL协议主要是服务提供商对用户信息保密的承诺,这有利于提供商而不利于消费者,同时SSL还存在一些问题,例如只能提供交易中客户域服务器间的双方认证,在涉及多方的电子交易中,SSL协议并不能协调各方的安全传输和信任关系。TLS(Transport Layer Security)是在SSL3.0基础上发展起来的,它使用了新的加密算法,因此同HTTPS之间不兼容,TLS用于两个通信应用程序之间,提供保密性和数据完整性,该协议是由两层子协议组成的,包括TLS记录协议(TLS Record)和TLS握手协议(TLS Handshake),较低的层为TLS记录协议,位于TCP协议之上,TLS握手协议具有三个属性,其一是可以使用非对称的密码术来认证对等方的身份,其二是共享加密密钥的协商是安全的,对偷窃者来说协商加密是难以获得的,此外经过认证的连接不能获取加密,即使是进入连接中间的攻击者也不能,其三是协商是可靠的,如果没有经过通信方成员的检测,任何攻击者都不能修改通信协商。TLS独立于高层协议,如HTTP协议,高层协议如HTTP协议可以透明的分布在TLS协议上面,然而,TLS标准并没有规定应用程序如何在TLS上增加安全性,它把如何启动TLS握手协议及如何解释交换的认证证书的决定权留给协议的设计者和实施者来判断。

    WebKit的实现

    首先看WebKit为了防止XSS攻击所做的工作,下图是WebKit中启动XSS过滤功能所使用的相关基础设施,为了防止XSS攻击,需要在解释HTML的过程中进行XSS过滤,也就是对词法分析器分析之后的词语(Token)进行过滤,以发现潜在的问题:
    这里写图片描述
    基本工作是这样,在HTMLDocumentParser类揭示出一个词语之后,如果需要进行XSS过滤功能,则每一个词语使用HTMLDocumentParser类的XSSAuditor对象来进行过滤,也就是图中的XSSAudior::filterToken函数,对于每一个词语,该函数进行过滤并生成相应的结果XSSInfo对象,该对象包含是否需要阻止整个页面渲染等信息,XSSAuditor不做决定,而是由HTMLDocumentParser将这些信息交给XSSAuditorDelegate类来处理,在根据这些信息来生成报告,XSSAuditorDelegate将结果报告发送给“report-uri”,XSS有很多种攻击的类型,这里主要包括对于元素开始和结束及其属性的检查,同时对于一些特定类型的词语进行过滤,包括input、form、button、iframe、script等,当发现潜在危险的时候再生成相应的结果信息此处为XSSInfo对象。其次是CSP方面的支持,下图是WebKit支持CSP所定义的相关基础设施,同时包括Origin的定义,其中对于CSP支持的主要部分是ContentSecurityPolicy和SecurityContext这两个类:
    这里写图片描述

    • ContentSecurityPolicy:主要包括对于规范中定义的各个字段的解释和解释后内容的保存,如图中的didReceiveHeader函数就是处理服务器端的HTTP消息头,该类将指令和指令的内容保存在”m_policies”中,形成一个列表
    • SecurityContext:支持安全机制的上下文类,包含Origin对象和ContentSecurityPolicy对象,其他对CSP等的调用都是通过该类来获取的

    图中最下部分为两个类WebSecurityOrigin和WebSecurityPolicy,这是WebKit的Chromium移植定义的两个接口,可以被Chromium调用,它们都有内部的实现,具体分别是SecurityOrigin和SecurityPolicy,SecurityOrigin就是规范中对于Origin的定义,而SecurityPolicy就是对CSP策略的定义,通过WebSecurityPolicy接口,Chromium可以自定义一些策略并设置到WebKit中。Document类间接继承了SecurityContext,由此Document也继承了CSP的设置,因为Document会在各处都使用,这样方便调用CSP的功能,DOMSecurityPolicy为了将CSP的信息暴露到JavaScript中,这样JavaScript代码可以获取CSP定义的内容,如“script-src”指令所定义的允许访问的域,ResourceFetcher是获取资源的类,根据CSP的定义,对于各种类型的资源,在获取之间都需要检查该资源是否在CSP定义的允许范围内,如果不在,则拒绝请求,并报告错误,如果在,则发起请求,该请求需要依赖SecurityPolicy提供的一些信息。最后是CORS的支持,下图是WebKit支持CORS所涉及的一些类,其中最主要的是CrossOriginAccesControl部分,它不是一个类,里面只是包含了一组全局函数,用来帮助生成符合CORS规范的“Preflight”请求或者其他简单请求,同时包括处理来自回复端的消息,在WebKit使用WebURLLoader请求的时候,使用这些方法能够生成相应的请求:
    这里写图片描述

    沙箱模型

    原理

    一般而言,对于网络上的网页中的JavaScript代码和插件是不受信的,特别是一些故意设计侵入游览器运行的主机代码更是危险,通过一些手段或者游览器中的漏洞,这些代码可能获取了主机的管理权限,这对主机系统来说十分危险,所以除了保证网页本身之外,还需要保证游览器和游览器所在的系统不存在危险。对于网络上的网页,游览器认为它们是不安全的,因为网页总是存在各种可能性,也许是无意或有意的攻击,如果有一种机制,将网页的运行限制在一个特定的环境中,也就是一个沙箱中,使它只能访问有限的功能,那么即使网页工作的渲染引擎被攻击,它也不能够获取渲染引擎工作的主机系统中的任何权限,这就是沙箱模型的思想。Chromium是以多进程为基础的,网页的渲染在一个独立的Renderer进程中,这位实现沙箱模型提供了基础,因为可以相对容易的使用一些技术将整个网页的渲染过程放在一个受限的进程中来完成,如下图所示,受限的环境只能被某些或者很少的系统调用而且不能直接访问用户数据,沙箱模型工作的基本单位就是进程。
    这里写图片描述
    Chromium的沙箱模型是利用系统提供的安全技术,让网页在执行过程中不会修改操作系统或者是访问系统中的隐私数据,而需要访问系统资源或者说是系统调用的时候,通过一个代理机制来完成。

    实现机制

    由于沙箱模型依赖操作系统提供的技术,而不同操作系统提供的安全技术是不一样的,这意味着不同操作系统上的实现是不一致的,需要分别针对不同平台来讨论,但是不管是Linux还是Windows,或者是其他平台,Chromium都是在进程的力度下来实现沙箱模型,也就是说需要运行在沙箱下的操作都是一个单独的进程:
    这里写图片描述
    图中右侧是目标进程,也就是需要在沙箱中运行的代码,左侧是代理进程,它需要负责创建目标进程并为目标进程设置各种安全策略,同时建立IPC连接,接受目标进程的各种请求,因为目标进程是不能访问过多资源的。

    Linux

    在Linux上,沙箱模型分成两个层,第一层是阻止某个或者某些进程通常能够访问的资源,chromium中称为“语义层,这里使用的系统技术主要是“setuid“,第二层是防止进程访问能够攻击内核的接口或者供给面,这里使用的系统技术主要是”Seccomp”,在沙箱机制启动之后,如果运行Chromium程序,会产生下面的进程层次结构,它是一棵树,树的根节点是“browser“进程,该进程启动后,会孵化多个子进程,包括”GPU“、”chrome_sandbox“等进程,而对于沙箱模型来说,这里关注”chrome_sandbox“进程,它的目的主要是使用”setuid“技术来实现模型的第一层,生成了”zygote“子进程,其中”chrome_sandbox“进程使用的是上面介绍的目标”chrome_sanbox”生成的二进制可执行文件,而其它的是目标”chrome“生成的结果,二者是不一样的。
    这里写图片描述
    生成第一个”zygote“之后,该进程会生成两个子进程,第一个是”nacl-helper“进程,是为了支持NaCl插件进程服务的,第二个又是一个”zygote“,这个不同于它的父亲,主要是为了生成各种”Renderer“进程服务,这样每个”Renderer“进程经过上面的过程后都会使用沙箱机制进行处理,网页在”Renderer“中的运行就收到了限制,Renderer进程域代理进程通过进程间通信机制来交互,所有的请求都是发送给代理进程,代理进程将结果返回给Renderer进程,这里的代理进程就是Browser进程,Browser进程拥有访问这些资源和系统调用的权限。其中第一层主要使用两种技术:

    • 使用setuid来为新进程设置新用户ID和组ID,根据Linux的规定,两个不同用户ID之间的数据是隔离开的,这将Renderer进程同Browser进程分开,后者拥有访问很多关键数据的能力,如各个网页的Cookie,在现在的Chromium实现中,不再使用setuid来实现,而是使用CLONE_NEWPID标记,该标记是在Linux系统调用clone时设置,从而为新进程创建一个新的名空间,也就是上面描述的文件系统等
    • 显示网络访问,Chromium使用标记”CLONE_NEWNET“设置在调用”clone“系统调用的参数中,使用这这些技术之后克隆出来的进程就同父进程分离开来,包括新文件系统等和限制网络的访问等

    第二层使用的主要技术是Seccomp和Seccomp-BPF,seccomp是Linux内核提供的一种简单的沙箱机制,它能够允许进程进入一种不可逆的安全状态,进入该状态的进程只能够调用4个系统调用,包括exit、sigreturn、read和write,而且最后两个系统调用只能操作已经打开的文件描述符,如果该进程尝试调用其他的系统调用,那么内核会通过SIGKILL信号来杀死该进程,进入该按去哪状态的方法就是使用系统调用prctl社会自标记位PR_SET_SECCOMP就可以了,前提是系统的内核在编译的时候就加入了对Seccomp的支持,因为不是所有使用Linux内核的操作系统都能打开该机制,Seccomp-BPF是Seccomp及时的一个扩展,它允许使用BPF所定义的方法来将系统调用转变成BPF格式的小程序,BPF(Berkeley Packet Filter)原是Berkeley开发的一种用来过滤网络包的技术,现在被应用在Seccomp,Seccomp-BPF将系统调用转变成BPF格式的小程序,这些小程序能够被内核所解释,这样每个系统调用的次数和参数都能够被重新评估或者被限制。对于开发者来说,如果想要关闭第二层的沙箱技术只需在命令行韩总加入参数”–disable-seccomp-filter-sandbox“就可以了,对于Android系统来讲,虽然Android是基于Linux内核开发出来的,但还是有些区别,目前沙箱机制的第二层在Android上并没有得到支持,只是第一层得到了支持,但是在Android上,系统支持的安全机制都已经在Chrome的Android版本上得到了启动,主要体现在两个方面,第一是SUID,Android系统上稍微不同,它是UID isolation(UID隔离技术),Android可以为每一个进程设置一个新的UID,这些每个进程之间就不能随意修改和访问数据,这是由Linux内核机制来保证的。

    展开全文
  • 导语 在android的世界了,不同的软件,硬件信息就像一个国家的经济水平,军事水平,不同的配置参数,代表着一个android帝国的强弱,所以厂商喜欢打配置...Android安全机制 具体内容Android系统信息的获取由于android手

    导语

    在android的世界了,不同的软件,硬件信息就像一个国家的经济水平,军事水平,不同的配置参数,代表着一个android帝国的强弱,所以厂商喜欢打配置战。

    主要内容

    • Android系统信息的获取
    • PackageManager的使用
    • ActivityManager的使用
    • 解析Packages.xml获取系统信息
    • Android安全机制

    具体内容

    Android系统信息的获取

    由于android手机的开源性,手机的配置各种各样,那些优化大师之类的东西,都可以跑分和看配置信息,那他们是从哪里知道这些信息的呢?遥想获取系统的配置信息,通常可以从以下两个方面获取:
    - android.os.Build
    - SystemProperty

    android.os.Build

    android.os.Build类里面的信息非常的丰富,它包含了系统编译时的大量设备,配置信息,我们列举一点:
    - Build.BOARD——主板
    - Build.BRAND——Android系统定制商
    - Build.SUPPORTED_ABIS——CPU指令集
    - Build.DEVICE——设备参数
    - Build.DISPLAY——显示屏参数
    - Build.FINGERPRINT——唯一编号
    - Build.SERIAL——硬件序列号
    - Build.ID——修订版本列表
    - Build.MANUFACTURER——硬件制造商
    - Build.MODEL——版本
    - Build.HARDWARE——硬件名
    - Build.PRODUCT——手机产品名
    - Build.TAGS——描述Build的标签
    - Build.TYPE——Builder类型
    - Build.VERSION.CODENAME——当前开发代号
    - Build.VERSION.INCREMENTAL——源码控制版本号
    - Build.VERSION.RELEASE——版本字符串
    - Build.VERSION.SDK_INT——版本号
    - Build.HOST——host值
    - Build.USER——User名
    - Build.TIME——编译时间

    上面的一些参数没有注释,他们来自系统的RO值中,这些值都是手机生产商配置的只读的参数值,根据厂家的配置不同而不同,接下来我们再来看一下另一个存储设备软硬件信息的类——SystemProperty。

    SystemProperty

    SystemProperty类包含了许多系统配置属性值和参数,很多信息和上面通过android.os.Build获取的值是相同的,我们列举一些常用的:
    - os.version——OS版本
    - os.name——OS名称
    - os.arch——OS架构
    - user.home——home属性
    - user.name——name属性
    - user.dir——Dir属性
    - user.timezone——时区
    - path.separator——路径分隔符
    - line.separator——行分隔符
    - file.separator——文件分隔符
    - java.vendor.url——Java vender Url属性
    - java.class.path——Java Class属性
    - java.class.version——Java Class版本
    - java.vendor——Java Vender属性
    - java.version——Java版本
    - java.home——Java Home属性

    Android系统信息实例

    下面我们用一个简单的实例来了解一下把。

    通过android.os.Build这个类,我们可以直接获取到Build提供的系统信息,而通过System.getProperty(“xxx”),我们可以访问到系统的属性。

    在实例中获取到的信息与上述的基本一致,运行如图。

    tv_message.append("主板:"+ Build.BOARD+"\n");
    tv_message.append("Android系统定制商:"+ Build.BRAND+"\n");
    tv_message.append("CPU指令集:"+ Build.SUPPORTED_ABIS+"\n");
    tv_message.append("设置参数:"+ Build.DEVICE+"\n");
    tv_message.append("显示屏参数:"+ Build.DISPLAY+"\n");
    tv_message.append("唯一编号:"+ Build.SERIAL+"\n");

    用System.getProperty。

    tv.append("OS版本:"+System.getProperty("os.version")+"\n");
    tv.append("OS名称:"+System.getProperty("os.name")+"\n");
    tv.append("OS架构:"+System.getProperty("os.arch")+"\n");
    tv.append("Home属性:"+System.getProperty("user.home")+"\n");
    tv.append("Name属性:"+System.getProperty("user.name")+"\n");

    代码贴上一点就可以了

    运行的实例程序中我们可以看到,我们已经获取到了相当多的系统信息,那么这些信息的来源又是哪儿呢?记得我们分析android系统目录的时候提到过,在system/build.prop中,包含了很多的RO值,打开命令窗,通过cat build.prop可以看到。

    这里我们可以看到很多前面通过android.os.Build所获取到的系统信息,同时,在adb shell中,还可以通过getprop来获取对应的值。

    除了上述的两个方法,android系统还在另外一个非常重要的目录来存储系统信息——/proc目录,在adb shell中进入/proc目录,通过ll命令查看文件信息。

    看了这么多系统信息,应该看Apk应用信息了,在ADB Shell命令中,有两个非常强大的助手,PM和AM,PM主宰着应用的包管理,而AM主宰着应用的活动管理。

    PackageManager——APK应用程序信息获取值

    我们看一张图:

    Package结构图

    最里面的框就代表整个Activity的信息,系统提供了ActivityInfo类来进行封装。
    而Android提供了PackageManager来负责管理所有已安装的App,PackageManager可以获得AndroidManifest中不同节点的封装信息,下面是一些常用的封装信息:

    • ActivityInfo

      ActivityInfo封装在了Mainfest文件中的< activity >和< eceiver>之间的所有信息,包括name、icon、label、launchMode等。

    • ServiceInfo

      ServiceInfo与ActivityInfo类似,封装了< service>之间的所有信息。

    • ApplicationInfo

      它封装了< application>之间的信息,特别的是,ApplicationInfo包含了很多Flag,FLAG_SYSTEM表示为系统应用,FLAG_EXTERNAL_STORAGE表示为安装在SDcard上的应用,通过这些flag可以很方便的判断应用的类型。

    • PackageInfo

      PackageInfo包含了所有的Activity和Service信息。

    • ResolveInfo

      ResolveInfo包含了< intent>信息的上级信息,所以它可以返回ActivityInfo、ServiceInfo等包含了< intent>的信息,经常用来帮助找到那些包含特定intent条件的信息,如带分享功能、播放功能的应用。

    有了这些封装的信息后,还需要有特定的方法来获取它们,下面就是PackageManager中封装的用来获取这些信息的方法:
    - getPackageManager():通过这个方法可以返回一个PackageManager对象。
    - getApplicationInfo():以ApplicationInfo的形式返回指定包名的ApplicationInfo。
    - getApplicationIcon():返回指定包名的Icon。
    - getInstalledApplications():以ApplicationInfo的形式返回安装的应用。
    - getInstalledPackages():以PackageInfo的形式返回安装的应用。
    - queryIntentActivities():返回指定Intent的ResolveInfo对象、Activity集合。
    - queryIntentServices():返回指定Intent的ResolveInfo对象、Service集合。
    - resolveActivity():返回指定Intent的Activity。
    - resolveService():返回指定Intent的Service。

    根据ApplicationInfo的flag来判断App的类型:

    • 如果当前应用的flags & ApplicationInfo.FLAG_SYSTEM != 0则为系统应用。
    • 如果flags & ApplicationInfo.FLAG_SYSTEM <= 0 则为第三方应用。
    • 特殊的当系统应用升级后也会成为第三方应用,此时 flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP != 0。
    • 如果flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE != 0 则为安装在SDCard上的应用。

    我们通过一个实例来分析。
    我们封装一个Bean来保存我们所需的字段:

    package com.lgl.systemmesage;
    
    import android.graphics.drawable.Drawable;
    
    /**
     * Bean
     * Created by LGL on 2016/4/28.
     */
    public class PMAPPInfo {
    
        //应用名
        private String appLabel;
        //图标
        private Drawable appIcon;
        //包名
        private String pkgName;
    
        //构造方法
        public PMAPPInfo(){
    
        }
    
        public String getAppLabel() {
            return appLabel;
        }
    
        public void setAppLabel(String appLabel) {
            this.appLabel = appLabel;
        }
    
        public Drawable getAppIcon() {
            return appIcon;
        }
    
        public void setAppIcon(Drawable appIcon) {
            this.appIcon = appIcon;
        }
    
        public String getPkgName() {
            return pkgName;
        }
    
        public void setPkgName(String pkgName) {
            this.pkgName = pkgName;
        }
    }

    接下来,我们通过上面的方法判断各种类型的应用,我们的主布局:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
    
        <Button
            android:id="@+id/btn_all"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="All APP"
            android:textAllCaps="false" />
    
        <Button
            android:id="@+id/btn_other"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Other App"
            android:textAllCaps="false" />
    
        <Button
            android:id="@+id/btn_system"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="System App"
            android:textAllCaps="false" />
    
        <ListView
            android:id="@+id/mListView"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1"></ListView>
    
    </LinearLayout>

    这里有一个listview,所以我们需要一个adapter和一个item:

    package com.lgl.systemmesage;
    
    import android.content.Context;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.BaseAdapter;
    import android.widget.ImageView;
    import android.widget.TextView;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 数据源
     * Created by LGL on 2016/4/28.
     */
    public class PkgAdapter extends BaseAdapter {
        private Context mContext;
        private List<PMAPPInfo> mList;
    
        public PkgAdapter(Context context) {
            mContext = context;
            mList = new ArrayList<>();
        }
    
        public void addAll(List<PMAPPInfo> list) {
            mList.clear();
            mList.addAll(list);
            notifyDataSetChanged();
        }
    
        @Override
        public int getCount() {
            return mList.size();
        }
    
        @Override
        public PMAPPInfo getItem(int position) {
            return mList.get(position);
        }
    
        @Override
        public long getItemId(int position) {
            return position;
        }
    
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder;
            PMAPPInfo item = getItem(position);
            if (convertView == null) {
                holder = new ViewHolder();
                convertView = LayoutInflater.from(mContext).inflate(R.layout.list_item, parent, false);
                holder.mIcon = (ImageView) convertView.findViewById(R.id.iv_icon);
                holder.mLabel = (TextView) convertView.findViewById(R.id.tv_label);
                holder.mPkgName = (TextView) convertView.findViewById(R.id.tv_pkg_name);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();
            }
            holder.mIcon.setImageDrawable(item.getAppIcon());
            holder.mLabel.setText(item.getAppLabel());
            holder.mPkgName.setText(item.getPkgName());
            return convertView;
        }
    
        static class ViewHolder {
            ImageView mIcon;
            TextView mLabel;
            TextView mPkgName;
        }
    }

    item就简单了:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/empty"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center_vertical"
        android:orientation="horizontal">
    
        <ImageView
            android:id="@+id/iv_icon"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />
    
        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_marginLeft="15dp"
            android:orientation="vertical">
    
            <TextView
                android:id="@+id/tv_label"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content" />
    
            <TextView
                android:id="@+id/tv_pkg_name"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content" />
    
        </LinearLayout>
    
    </LinearLayout>

    那我们主程序的逻辑就是:

    package com.lgl.systemmesage;
    
    import android.content.pm.ApplicationInfo;
    import android.content.pm.PackageManager;
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.ListView;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 软件列表
     * Created by LGL on 2016/4/28.
     */
    public class APP extends AppCompatActivity implements View.OnClickListener{
    
        private PackageManager mPackageManager;
    
        private ListView mListView;
        private PkgAdapter mAdapter;
        List<PMAPPInfo> result;
    
        protected void onCreate( Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_app);
    
            mPackageManager = getPackageManager();
            mListView = (ListView) findViewById(R.id.mListView);
            mAdapter = new PkgAdapter(this);
            mListView.setEmptyView(findViewById(R.id.empty));
            mListView.setAdapter(mAdapter);
            findViewById(R.id.btn_all).setOnClickListener(this);
            findViewById(R.id.btn_other).setOnClickListener(this);
            findViewById(R.id.btn_system).setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btn_all:
                    result = getAppInfo(R.id.btn_all);
                    break;
                case R.id.btn_other:
                    result = getAppInfo(R.id.btn_other);
                    break;
                case R.id.btn_system:
                    result = getAppInfo(R.id.btn_system);
                    break;
                default:
                    result = new ArrayList<>();
            }
            mAdapter.addAll(result);
        }
    
        private List<PMAPPInfo> getAppInfo(int flag) {
            List<ApplicationInfo> appInfos = mPackageManager.getInstalledApplications(
                    PackageManager.GET_UNINSTALLED_PACKAGES);
            List<PMAPPInfo> list = new ArrayList<>();
            //根据不同的flag来切换显示不同的App类型
            switch (flag) {
                case R.id.btn_all:
                    list.clear();
                    for (ApplicationInfo appInfo : appInfos) {
                        list.add(makeAppInfo(appInfo));
                    }
    
                    break;
                case R.id.btn_other:
                    list.clear();
                    for (ApplicationInfo appInfo : appInfos) {
                        if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) <= 0) {
                            list.add(makeAppInfo(appInfo));
                        } else if ((appInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0){
                            list.add(makeAppInfo(appInfo));
                        }
                    }
                    break;
                case R.id.btn_system:
                    list.clear();
                    for (ApplicationInfo appInfo : appInfos) {
                        if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
                            list.add(makeAppInfo(appInfo));
                        }
                    }
                    break;
            }
            return list;
        }
    
        private PMAPPInfo makeAppInfo(ApplicationInfo appInfo) {
            PMAPPInfo info = new PMAPPInfo();
            info.setAppIcon(appInfo.loadIcon(mPackageManager));
            info.setAppLabel(appInfo.loadLabel(mPackageManager).toString());
            info.setPkgName(appInfo.packageName);
            return info;
        }
    }

    效果图:

    效果图

    ActivityManager——Apk应用信息获取

    前面所使用的packagemanager获取的是所有的应用包名,但是哼哈二将还有一名大奖没有说道,那就是ActivityManager了,他的功能四号不逊色前者,事实上,他在使用上各有侧重点,前者侧重于获取应用的包信息,后者获取运行的应用程序信息。

    同packagemanager一样,ActivityManager也封装了不少的Bean对象,我们选几个重点来说一下:
    - ActivityManager.MemoryInfo——MemoryInfo有几个非常重要的字段:availMem(系统可用内存),totalMem(总内存),threshold(低内存的阈值,即区分是否低内存的临界值),lowMemory(是否处于低内存)。
    - Debug.MemoryInfo——这个MemoryInfo用于统计进程下的内存信息。
    - RunningAppProcessInfo——运行进程的信息,存储的字段有:processName(进程名),pid(进程pid),uid(进程uid),pkgList(该进程下的所有包)
    - RunningServiceInfo——运行的服务信息,在它里面同样包含了一些服务进程信息,同时还有一些其他信息。activeSince(第一次被激活的时间、方式),foreground(服务是否在后台执行)。

    我们同样的用一个实例来讲解:

    package com.lgl.systemmesage;
    
    /**
     * Created by LGL on 2016/4/28.
     */
    public class AMProcessInfo {
    
        private String pid;
        private String uid;
        private String memorySize;
        private String processName;
    
        public  AMProcessInfo(){
    
        }
    
        public String getPid() {
            return pid;
        }
    
        public void setPid(String pid) {
            this.pid = pid;
        }
    
        public String getUid() {
            return uid;
        }
    
        public void setUid(String uid) {
            this.uid = uid;
        }
    
        public String getProcessName() {
            return processName;
        }
    
        public void setProcessName(String processName) {
            this.processName = processName;
        }
    
        public String getMemorySize() {
            return memorySize;
        }
    
        public void setMemorySize(String memorySize) {
            this.memorySize = memorySize;
        }
    }

    然后我们用一个方法就可以获取到了:

     /**
         * 正在运行
         * @return
         */
        private List<ActivityManager.RunningAppProcessInfo> getRunningProcossInfo(){
            mAMProcessInfo = new ArrayList<>();
            List<ActivityManager.RunningAppProcessInfo>appRunningList = activityManager.getRunningAppProcesses();
    
            for (int i = 0;i<appRunningList.size();i++){
                ActivityManager.RunningAppProcessInfo info = appRunningList.get(i);
                int pid = info.pid;
                int uid = info.uid;
                String procossName = info.processName;
                int[]memoryPid = new int[]{pid};
                Debug.MemoryInfo[] memoryInfos = activityManager.getProcessMemoryInfo(memoryPid);
    
                int memorySize = memoryInfos[0].getTotalPss();
    
                AMProcessInfo processInfo = new AMProcessInfo();
                processInfo.setPid(""+pid);
                processInfo.setUid(""+uid);
                processInfo.setMemorySize(""+memorySize);
                processInfo.setProcessName(procossName);
                appRunningList.add(processInfo);
            }
            return  appRunningList;
        }

    效果图:

    效果图

    解析Packages.xml获取系统信息

    熟悉Android开机启动流程的朋友大概知道,在系统初始化到时候,packagemanager的底层实现类packagemanagerService会去扫描系统的一些特定目录,并且解析其中的Apk文件,同时Android把他获取到的应用信息保存到xml中,做成一个应用的花名册,就是data/system/apckages.xml,我们用adb pull命令把他导出来,里面的信息也太多了,但是我们只要知道结果根节点就可以了。

    • 标签

      permissions标签定义了现在系统所有的权限,也分两类,系统定义的和app定义的。

    • 标签

      package代表的是一个apk的属性。其中各节点的信息含义大致为:

      • name:APK的包名
      • cadePath:APK安装路径,主要在system/app和data/app两种,前者放系统级别的,后者放系统安装的
      • userid:用户ID
      • version:版本
    • 标签

      对应apk的清单文件,记录apk的权限信息。

    通过这个xml文件的标签,可以获取到很多手机应用的信息,通常在进行系统层开发的时候,可以通过这个xml获取更多有意义的东西。

    Android安全机制

    道高一尺魔高一丈,自古以来就没有什么绝对的安全,所以Google也建立起了一层层的壁垒,保护Android的核心安全,我们来详细了解一下。

    Android安全机制介绍
    • 第一道防线

      代码安全机制——代码混淆proguard。
      由于java语言的特殊性,即使是编译成apk的应用程序也存在反编译的风险,而proguard则是在代码从上对app的第一道程序,他混淆关键代码,替换命名,让破坏者阅读难,同样也可以压缩代码,优化编译后的字节。

    • 第二道防线

      应用接入权限控制——清单文件权限声明,权限检查机制。
      任何app在使用Android受限资源的时候,都需要显示向系统生命权限,只有当一个应用app具有相应的权限,才能申请相应的资源,通过权限机制的检查并且使用并且使用系统的Binder对象完成对系统服务的调用,但是这道防线也有先天的不足,如以下几项:

      • 被授予的权限无法停止。
      • 在应用声明app使用权限的时候,用户无法针对部分权限进行限制。
      • 权限的判断机制与用户的安全理念相关。

      Android系统通常按照以下顺序来检查操作者的权限:

      • 首先,判断permission名称.如果为空则直接返回PERMISSION_DENIED
      • 其次。判断Uid,如果为0则为root权限,不做权限控制,如果为systyemsystem service的uid则为系统服务.不做权限控制:如果Uid与参数中的请求uid不同则返回PERMISSION_DENIED 。
      • 最后,通过调用packagemanageservice.checkUidPermission()方法来判断该uid是否具有相应的权限,该方法会去xml的权限列表和系统级的权限进行查找 。

      通过上面的步骤Android就确定了使用者是否具有某项使用权限。

    • 第三道防线

      应用签名机制一数字证书。
      Android中所有的app都会有个数字证书,这就是app的签名.数字证书用于保护app的作者和其app的信任关系,只有拥有相同数字签名的app,才会在升级时被认为是同一app,而且Android系统不会安装没有签名的App。

    • 第四道防线

      Linux内核层安全机制一一Uid 访问权限控制。
      Animid本质是基于Linux内核开发的,所以Android同样继承了Linux的安全特性,比如Linux文件系统的权限控制是由user,group,other与读,写,执行的不同组合来实现的,同样,Android也实现了这套机制”通常情况下.只有system,root用户才有权限访问到系统文件,而一般用户无法访问。

    • 第五道防线

      Android虚拟机沙箱机制——沙箱隔流。
      Android的App运行在虚拟机中 因此才有沙箱机制,可以让应用之间相互隔离,通常情况下,不同的应用之间不能互相访问。每个App都单独的运行在虚似机中,与其他应用完全隔离.在实现安全机制的基础上,也让应用之间能够互不影响,即时一个应用崩溃,也不会导致其他应用异常。

    虽然通过以上的五道防线,仍然不能完全保证Android的核心安全,但却可以在最大程度上给破坏者增加难度,从另一方面来说,这些破坏者的破解也真是推动Android安全机制逐渐健全的动力。

    Android系统安全隐患

    虽说Android建立起来了N道防线,但是没有绝对的安全所以在Android中也有一些破解之法。

    • 代码漏洞

      这个问题存在世界上所有的程序中,没有谁敢保证自己的程序没有bug,有漏洞,如果遇到这种问题,大家只能尽快的升级版本,更新补丁,才能杜绝利用漏洞的攻击装,比如Android的LaunchAnyWhere,FakeId,这些都是bug,就是在编写的时候产生的漏洞,只有期待官方的更新了。

    • root风险

      Root权限是指Android的系统管理员权限,类似于windows系统中的Administrator。具有Root权限的用户可以访问和修改手机中几乎所有的文件,“Root”在一段时间内一度成为Android的代名词,无Root,不Android”。的确,,Root掉手机后,可以解锁很多普通用户无法完成的工作,如限制各个应用app的数据流量。系统文件管理,自定义修改系统等,但同时手机的安全性也会因此大打折扣。随着android系统越来越完善,root的必要性也越来越低普通用户在不root的情况下,完全可以正常使用大部分App。需要Root权限的大多为一些开发者,由于开发的需要,,将手机root,而root后的手机,就少了一层Linux的天然屏障,整个系统核心就完全暴露在人侵者面前,在你没有察觉的情况下大肆破坏。所以,针对普通用户,希望都尽量不要Root手机以免带来不必要的损失。

    • 安全机制不健全

      由于Android的权限管理机制并不完美,所以很多手机开发商,通常会在Rom中增加自己的一套权限管理工具来帮助用户控制手机中应用的权限,如应用许可。

    • 用户安全意识

      用户对于安全隐患的察觉里也是保护手机安全的一个重要因素。用户可以通过在正规的应用市场下载和安装应用时通过列出来的应用权限申请信息来大致判断一个应用的安全性,比如我们曾经十分喜欢用的“xx神器”,其实没有一点技术含量,无非就是在你安装了应用之后遍历一遍你的联系人并发送带有链接的短信而已当用户在安装不明来源的应用时如果一个娱乐类型的app生命权限的时候不仅要联系人又要短信权限,这个时候就需要警惕了,用户也可以在市场上下载一些安全类App,如LEB安全大师,360安全等, 虽然这些软件会加重系统负担,但是为了安全也是值得的。

    • Android开发原则与安全

      众所周知,Android与ios系统一个非常显著的区别就是,一个是开放系统,一个是封闭系统,开放自然有开放的好处,技术进步快,产品丰富,封闭也有封闭的好处,安全性高,可控性高,Google本着开源的精神开放了Android的源代码,但随之而来的各种安全问题也让Android倍受诟病,过度的开放与可定制化,不仅造成了Android的碎片化严重,同时也给很多不法应用以可乘之机,但可喜的是,随着Android的发展日益壮大,Google也在着手处理开发与安全的问题,相信在不久的将来,这一矛盾会越来越小。

    Android Apk反编译

    使用三个工具:
    - apktool:反编译apk的xml文件。
    - Dex2jar:classes.dex转为jar文件。
    - jd-gui:查看jar文件。

    Android APK 加密

    由于java字节的特殊性,他很容易反编译,为了能够保护好代码,我们通常会使用一些措施,比如说混淆,而在Android studio中,可以很方便的使用ProGuard,在Gradle Scripts目录下。

     buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }

    这里的minifyEnabled属性就是控制是否启动ProGuard,这个属性以前叫做runProgyard,在Android studio1.1的时候改成minifyEnabled,将他设置成true,就可以混淆了,他位于《SDK目录下的tools/proguard/proguard-android.txt目录下,大部分的情况下使用使用这个默认的混淆就好了,后面亦不过分是项目中自定义的混淆,可以在项目的app文件夹下找到这个文件,在这根文件里可以定义引用的第三方依赖库和混淆规则,配置好ProGuard之后,用AS到处apk即可。

    总结

    学会获取系统信息。

    进入我的CSDN戳这里(我的博客导航)

    展开全文
  • 研究了对基于ASP的信息安全管理机制的策略体系实行的前提,并且对其技术安全策略以及组织管理策略分别进行了分析,为基于ASP的信息网络安全管理能力的提升提供一定的参考和借鉴。
  • Kafka 安全机制

    2020-12-08 17:36:01
    kafka的安全机制是一个保护kafka的数据不对外暴露的一种策略,相当于隐藏了数据本身的接口,客户端消费数据的时候必须走安全机制才能正常有效的访问到数据本身,一般相对数据安全性要求较高或者订单,用户私密的信息的...
  • 网络信息传输的安全机制

    千次阅读 2018-06-08 21:14:21
    在不安全的信道上传输信息,会有哪些安全威胁: 试图颠覆已有过程来运行其他不应该执行的代码,比如蠕虫,利用缓冲区溢出的漏洞改写服务器代码来执行注入的蠕虫代码; 试图获得用户权限来运行恶意程序 ; 采用未经...
  • mysql 权限管理mysql 权限表 grant all on *.* ...... 账号信息保存在mysql.user 中,权限信息记录在mysql.db ,因为是数据库级别的授权授权 mysql 回收权限 mysql 用户管理mysql客户端登录默认...
  • 1.1安全机制

    2018-09-11 22:04:36
    1 安全机制 信息安全防护的目标 保密性 Confidentiality 完整性 Integrity 可用性 Usability 可控制性 Controlability 不可否认性 Non-repudiation 信息安全防护的环节 物理安全:各种设备/主机、机房环境 系统安全...
  • 1.1 安全机制

    2018-05-19 12:00:17
    安全机制 信息安全防护的目标 保密性(Confidentiality):是指阻止非授权的主体阅读信息。它是信息安全一诞生就具有的特性,也是信息安全主要的研究内容之一。更通俗地讲,就是说未授权的用户不能够获取敏感信息。...
  • Android系统信息安全机制主要内容: Android系统信息的获取 PackageManager的使用 ActivityManager的使用 Android安全机制 1.Android系统信息获取要获取系统的配置信息,通常可以从以下两个方面获取 android.os....
  • 消费者对食品质量安全信息的反馈机制,余建斌,,研究消费者对食品质量安全信息的反馈机制有助于解决由于信息不对称导致的食品质量安全问题。本文的研究结果显示:消费者遇到食品
  • Android群英传笔记——第九章:Android系统信息安全机制 本书也正式的进入尾声了,在android的世界了,不同的软件,硬件信息就像一个国家的经济水平,军事水平,不同的配置参数,代表着一个android帝国的强弱,...
  • 安全机制设计原则

    千次阅读 2020-03-21 16:27:56
    安全机制设计八大原则: ①经济性原则(Economy of Mechanism) 安全机制设计尽可能简单短小,从而在排查缺陷、检测漏洞时代码更容易处理 ②默认拒绝原则(Fail-Safe Defaults) 只要没有授权的信息就不允许访问 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,240
精华内容 2,496
关键字:

信息安全机制