`
JasonShieh
  • 浏览: 526724 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Android签名验证简介

 
阅读更多

Android原生自带了个安装器(packages\apps\PackageInstaller),

通过其中的源码PackageParser.java (frameworks\base\core\java\android\content\pm)
我们大概就能知道其签名验证机制的验证过程。
其中主要涉及2个函数:
函数1
public boolean collectCertificates(Package pkg, int flags) {
        pkg.mSignatures = null;

        WeakReference<byte[]> readBufferRef;
        byte[] readBuffer = null;
        synchronized (mSync) {
            readBufferRef = mReadBuffer;
            if (readBufferRef != null) {
                mReadBuffer = null;
                readBuffer = readBufferRef.get();
            }
            if (readBuffer == null) {
                readBuffer = new byte[8192];
                readBufferRef = new WeakReference<byte[]>(readBuffer);
            }
        }

        try {
            JarFile jarFile = new JarFile(mArchiveSourcePath);

            Certificate[] certs = null;

            if ((flags&PARSE_IS_SYSTEM) != 0) {
                // If this package comes from the system image, then we
                // can trust it...  we'll just use the AndroidManifest.xml
                // to retrieve its signatures, not validating all of the
                // files.
                JarEntry jarEntry = jarFile.getJarEntry(ANDROID_MANIFEST_FILENAME);
                certs = loadCertificates(jarFile, jarEntry, readBuffer);
                if (certs == null) {
                    Slog.e(TAG, "Package " + pkg.packageName
                            + " has no certificates at entry "
                            + jarEntry.getName() + "; ignoring!");
                    jarFile.close();
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES;
                    return false;
                }
                if (DEBUG_JAR) {
                    Slog.i(TAG, "File " + mArchiveSourcePath + ": entry=" + jarEntry
                            + " certs=" + (certs != null ? certs.length : 0));
                    if (certs != null) {
                        final int N = certs.length;
                        for (int i=0; i<N; i++) {
                            Slog.i(TAG, "  Public key: "
                                    + certs[i].getPublicKey().getEncoded()
                                    + " " + certs[i].getPublicKey());
                        }
                    }
                }
            } else {
                Enumeration<JarEntry> entries = jarFile.entries();
                final Manifest manifest = jarFile.getManifest();
                while (entries.hasMoreElements()) {
                    final JarEntry je = entries.nextElement();
                    if (je.isDirectory()) continue;

                    final String name = je.getName();

                    if (name.startsWith("META-INF/"))
                        continue;

                    if (ANDROID_MANIFEST_FILENAME.equals(name)) {
                        final Attributes attributes = manifest.getAttributes(name);
                        pkg.manifestDigest = ManifestDigest.fromAttributes(attributes);
                    }

                    final Certificate[] localCerts = loadCertificates(jarFile, je, readBuffer);
                    if (DEBUG_JAR) {
                        Slog.i(TAG, "File " + mArchiveSourcePath + " entry " + je.getName()
                                + ": certs=" + certs + " ("
                                + (certs != null ? certs.length : 0) + ")");
                    }

                    if (localCerts == null) {
                        Slog.e(TAG, "Package " + pkg.packageName
                                + " has no certificates at entry "
                                + je.getName() + "; ignoring!");
                        jarFile.close();
                        mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES;
                        return false;
                    } else if (certs == null) {
                        certs = localCerts;
                    } else {
                        // Ensure all certificates match.
                        for (int i=0; i<certs.length; i++) {
                            boolean found = false;
                            for (int j=0; j<localCerts.length; j++) {
                                if (certs[i] != null &&
                                        certs[i].equals(localCerts[j])) {
                                    found = true;
                                    break;
                                }
                            }
                            if (!found || certs.length != localCerts.length) {
                                Slog.e(TAG, "Package " + pkg.packageName
                                        + " has mismatched certificates at entry "
                                        + je.getName() + "; ignoring!");
                                jarFile.close();
                                mParseError = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES;
                                return false;
                            }
                        }
                    }
                }
            }
            jarFile.close();

            synchronized (mSync) {
                mReadBuffer = readBufferRef;
            }

            if (certs != null && certs.length > 0) {
                final int N = certs.length;
                pkg.mSignatures = new Signature[certs.length];
                for (int i=0; i<N; i++) {
                    pkg.mSignatures[i] = new Signature(
                            certs[i].getEncoded());
                }
            } else {
                Slog.e(TAG, "Package " + pkg.packageName
                        + " has no certificates; ignoring!");
                mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES;
                return false;
            }
        } catch (CertificateEncodingException e) {
            Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e);
            mParseError = PackageManager.INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING;
            return false;
        } catch (IOException e) {
            Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e);
            mParseError = PackageManager.INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING;
            return false;
        } catch (RuntimeException e) {
            Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e);
            mParseError = PackageManager.INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION;
            return false;
        }

        return true;
    }
 函数2
private Certificate[] loadCertificates(JarFile jarFile, JarEntry je,
            byte[] readBuffer) {
        try {
            // We must read the stream for the JarEntry to retrieve
            // its certificates.
            InputStream is = new BufferedInputStream(jarFile.getInputStream(je));
            while (is.read(readBuffer, 0, readBuffer.length) != -1) {
                // not using
            }
            is.close();
            return je != null ? je.getCertificates() : null;
        } catch (IOException e) {
            Slog.w(TAG, "Exception reading " + je.getName() + " in "
                    + jarFile.getName(), e);
        } catch (RuntimeException e) {
            Slog.w(TAG, "Exception reading " + je.getName() + " in "
                    + jarFile.getName(), e);
        }
        return null;
    }
 通过上面的代码,我们已经能够得到了签名的证书,通过证书我们就得到PublicKey,通过比较PublicKey我们就能比较签名是否一致,当然这里假设的是只有一个签名。
实例1
package edu.edut.robin.utils;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.PublicKey;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.util.Base64;

public class SigntureUtil
{
    final static String TAG = "Signture";

    public static String[] getPublicKeyString(PackageInfo pi)
    {
        PublicKey pubKeys[] = getPublicKey(pi);
        if (pubKeys == null || pubKeys.length == 0)
        {
            return null;
        }
        String[] strPubKeys = new String[pubKeys.length];
        for (int i = 0; i < pubKeys.length; i++)
            strPubKeys[i] = Base64.encodeToString(pubKeys[i].getEncoded(),
                    Base64.DEFAULT);
        return strPubKeys;
    }

    private static PublicKey[] getPublicKey(PackageInfo pi)
    {
        try
        {
            if (pi.signatures == null || pi.signatures.length == 0)
            {
                return null;
            }
            PublicKey[] publicKeys = new PublicKey[pi.signatures.length];
            for (int i = 0; i < publicKeys.length; i++)
            {
                byte[] signature = pi.signatures[i].toByteArray();
                CertificateFactory certFactory = CertificateFactory
                        .getInstance("X.509");
                InputStream is = new ByteArrayInputStream(signature);
                X509Certificate cert = (X509Certificate) certFactory
                        .generateCertificate(is);

                publicKeys[i] = cert.getPublicKey();
            }
        } catch (Exception ex)
        {

        }
        return null;
    }

    private static PublicKey[] getInstalledAppPublicKey(Context context,
            String packageName)
    {
        PackageManager pm = context.getPackageManager();
        PackageInfo pi;
        try
        {
            pi = pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
            if (pi != null && pi.versionName != null)
            {
                return getPublicKey(pi);
            }
        } catch (NameNotFoundException e)
        {
            // not installed
            return null;
        } catch (Exception e)
        {
            e.printStackTrace();
        }

        return null;
    }

    private static Certificate[] loadCertificates(JarFile jarFile, JarEntry je)
    {
        try
        {
            // We must read the stream for the JarEntry to retrieve
            // its certificates.
            byte[] readBuffer = new byte[1024];
            InputStream is = jarFile.getInputStream(je);
            while (is.read(readBuffer, 0, readBuffer.length) != -1)
                ;
            is.close();

            return (je != null) ? je.getCertificates() : null;
        } catch (IOException e)
        {
            e.printStackTrace();
        }
        return null;
    }

    public static boolean verifySignature(Context context, String packageName,
            String filePath)
    {
        boolean verifyed = true;
        try
        {
            PublicKey[] installedAppPubKeys = getInstalledAppPublicKey(context,
                    packageName);
            if (installedAppPubKeys == null||installedAppPubKeys.length==0)
            {
                // package not installed
                return true;
            }
            JarFile jarFile = new JarFile(filePath);
            verifyed = false;
            JarEntry je = jarFile.getJarEntry("classes.dex");
            Certificate[] certs = loadCertificates(jarFile, je);
            if (certs != null && certs.length > 0)
            {
                for (int i = 0; i < certs.length; i++)
                {
                    PublicKey pubKey = certs[i].getPublicKey();
                    for(int j=0;j<installedAppPubKeys.length;j++)
                    {
                        if (pubKey.equals(installedAppPubKeys[j]))
                        {
                            verifyed = true;
                            break;
                        }
                    }
                    if(verifyed)
                        break;
                }
            } else
            {
                verifyed = true;
            }

            jarFile.close();
        } catch (Exception e)
        {
            verifyed = true;
        }

        return verifyed;
    }

}
 关于数字签名的更多内容请阅读《数字签名简介
关于java本身的数字签名和数字证书请参考《Java中的数字签名和数字证书》和Jar文件的数字签名
结束
分享到:
评论

相关推荐

    Android so文件签名验证源代码

    本文将基于给定的"Android so文件签名验证源代码"主题,详细阐述Android SO文件的签名过程、NDK(Native Development Kit)的使用以及签名验证的重要性。 首先,了解Android应用签名机制是理解SO文件签名验证的基础...

    Android签名验证代码

    下面将详细阐述Android签名验证的流程和相关代码实现。 首先,我们需要理解签名的原理。Android使用Java的JAR签名机制,这基于公钥加密体系。开发者使用私钥对APK进行签名,系统则使用对应的公钥来验证签名。这样...

    java生成及验证android签名文件源码及生成签名文件

    本文将深入探讨Java如何生成及验证Android签名文件,并解析源码中的相关概念。 首先,让我们理解Android签名文件的核心作用。Android签名文件(通常为`.keystore`格式)是一个包含了应用开发者私钥的加密文件,用于...

    Android签名机制介绍

    一、Android签名机制--基础概念 1. 消息摘要算法 2. 非对称加密算法(RSA算法) ...三、Android签名机制--APK签名验证过程 1. APK签名验证概述 2. 简略调用流程 3. 详细校验流程(校验CERT.RSA) 4. 总结

    Android签名生成工具和签名格式转换工具

    1.1 定义:Android签名是一个数字证书,它包含开发者的信息(如名称、组织和证书有效期)以及用于验证应用的私钥。这个签名通过加密算法对APK文件进行签名,确保应用未被篡改。 1.2 作用: - 身份验证:验证应用是...

    一种Android数字签名验证机制漏洞探析.pdf

    本文深入探讨了Android系统数字签名验证机制中存在的一类漏洞,以及其成因和可能的解决方案。首先,文章介绍了数字签名和验证过程的基本原理,随后详细分析了Android系统数字签名机制的具体作用及其潜在的漏洞。 在...

    android apk sha256哈希值签名验证示例

    Android系统在安装APK时会自动进行签名验证。如果签名无效,系统会阻止安装,并显示相应的错误消息。开发者还可以在代码中添加自定义的签名验证逻辑,比如在应用启动时进行验证。 5. **安全最佳实践** - 使用强...

    mac android app 签名工具

    Android系统会检查APK的签名,只有签名验证通过的应用才能被安装。签名过程通常包括创建一个密钥对(公钥和私钥),使用私钥对APK进行签名,然后使用公钥进行验证。 对于开发者而言,二次签名的情况可能出现在以下...

    Windows版本 Android Apk签名工具

    在Android应用开发中,发布应用到Google Play或其他第三方市场前,必须对其进行签名。签名过程确保了应用程序的来源可追溯,并且在安装时提供了一定的安全性。本篇将详细讲解Windows版本的Android Apk签名工具及其...

    Android签名 签名格式转换 工具

    本文将深入探讨Android签名的概念、签名生成过程以及签名格式转换的相关知识。 首先,Android签名的核心作用包括: 1. **身份验证**:签名可以验证应用程序的开发者身份,帮助用户识别应用的来源,防止恶意篡改。 ...

    生成 Android 签名文件

    ### 生成Android签名文件 在Android应用开发过程中,签名是一个重要的环节。为了确保应用程序的完整性和安全性,每个发布的Android应用程序都需要进行签名。本篇文章将详细解释如何生成Android签名文件(通常为*....

    android原生系统签名文件

    首先,Android系统使用签名来验证软件包的来源和授权,以防止恶意代码的注入。在Android开发过程中,有多种签名文件用于不同的目的: 1. **平台签名** (platform.x509.pem 和 platform.pk8):这是用于签署系统核心...

    微信签名工具Android 安装包(Gen-Signature-android.apk)

    这个签名验证了应用的来源和开发者身份,并且在安装过程中确保APK文件未被篡改。签名过程使用密钥对APK进行加密,这有助于防止恶意代码的注入,同时允许系统跟踪应用的更新。 接下来,我们要讨论的是`.jks`文件。这...

    安卓签名获取工具 Android签名获取工具

    通常,Android签名过程涉及使用私钥对APK进行数字签名,以验证应用的来源并确保其未被篡改。签名过程不仅在安装时验证应用,还在更新或升级应用时起着重要作用。 首先,了解"MD5签名"。MD5(Message-Digest ...

    Android签名证书文件的解析和签名校验的加强

    1. **增强签名验证逻辑**:在原有的签名验证基础上增加额外的检查点,如验证签名者信息的有效性、签名证书的有效期等。 2. **使用更安全的哈希算法**:例如,从SHA1升级到SHA256或更高版本的算法,提高安全性。 3. *...

    可用的android签名工具

    这个签名验证了软件的来源和完整性,防止恶意篡改。签名过程包括生成一对密钥(公钥和私钥),使用私钥对APK或ROM进行签名,然后公钥和签名信息会被包含在安装包中,供系统验证。 该工具的主要功能是自动化这个过程...

    android系统签名工具

    Android签名过程主要涉及以下几个步骤: 1. **生成密钥对**:开发者使用如Keytool这样的工具,生成一对密钥——公钥和私钥。私钥用于签名,公钥则用于验证签名。 2. **签名APK**:使用私钥对APK的每个dex文件...

    Android签名工具

    - **身份验证**: 签名验证了应用的开发者身份,帮助用户识别和信任来源可靠的应用。 - **安全防护**: 签名可以检测APK是否在分发过程中被篡改,防止恶意代码的注入。 - **版本升级**: 同一应用的后续更新必须使用...

    android签名工具(支持Linux&MAC;下批量签名)

    首先,Android签名机制是为了验证应用程序的身份,防止篡改,并确保只有授权的应用才能安装和更新。每个APK文件在发布前都需要进行签名,以便Android系统可以检查其来源和权限。签名过程涉及到生成一个密钥对,包括...

Global site tag (gtag.js) - Google Analytics