使用Android Keystore进行加解密

最新推荐文章于 2024-07-07 03:44:05 发布
最新推荐文章于 2024-07-07 03:44:05 发布
阅读量2.8k 收藏 9
点赞数 2
分类专栏： android
原文链接：https://www.jianshu.com/p/06775ddf435f
版权

https://www.jianshu.com/p/06775ddf435f

国内使用Android Keystore加解密的应该很少吧，搜出来也基本都是Android打包时的Keystore，其实谷歌在很早之前就已经为Android提供了类似IOS的KeyChain功能，私钥存储在trustzone系统中，这个trustzone系统独立于Android系统，能做到私钥安全。
具体怎么安全，我们来了解一下加解密与签名的过程，本文不做复杂的深度解析，普通人也完全不需要了解这么透彻，想深入了解的可以google trustzon。
keystore加解密与签名的安全性其实很好理解，因为不管是应用还是Android系统本身都无法访问私钥，只能选择创建、删除与使用，从根源角度来杜绝私钥泄露的可能。当然因为google设计问题，早期安全性还是有一些问题的，建议直接从android6.0开始使用，android4.4与5.0也能用只是需要使用早期的KeyPairGeneratorSpec来创建，此类在android6.0已经被废弃。
说了那么多，可能有些人还是一头雾水，那么罗列一下android keystore的用处吧：

  1. 可以安全的加密本地数据，方便想安全存储但是不知道私钥怎么存放的用户（apk不管如何加固都存在被破解风险）
  2. 可以结合指纹进行指纹授权解密
  3. 在区块链行业加解密签名等尤为显著，此功能要比ios的安全区好用很多（据我所知，应用卸载，ios安全区的内容还在，这毫无安全可言）
    在使用过程中，我也遇到了几个问题，这里需要注意一下，不然一不小心就被坑了：
  4. keystore加解密是非线程安全的，所以一定要加锁（被网上的网友坑了一把，使用了别人提供的util工具，简直日了狗，毁人不倦）
  5. 不要轻易删除keystore，否则加密过的数据会面临无法解密的风险
  6. 私钥创建初始化耗时比较久，尽量一个私钥重复使用（此耗时和手机性能几乎无关，速度取决于trustzone的系统）
    好了，到了贴代码时间：

/**
 * @date 2019/11/12
 * @since 2.0
 * description:
 */

import android.security.KeyPairGeneratorSpec;
import android.security.keystore.KeyGenParameterSpec;
import android.security.keystore.KeyProperties;
import android.util.Base64;

import java.io.IOException;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.UnrecoverableEntryException;
import java.security.cert.CertificateException;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Calendar;
import java.util.GregorianCalendar;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import javax.security.auth.x500.X500Principal;

/**
 * 使用KeyStore+AES对称加密的方式
 *
 * 通过AES加密方式，用KeyGenerator生成秘钥，保存在Android Keystore中
 * 对数据进行加解密
 * <p>
 * 1、创建秘钥，保存在AndroidKeystore里面，秘钥别名为alias
 * 2、创建并初始化cipher对象，获取秘钥，对数据进行加解密
 *
 * https://blog.csdn.net/hpp_1225/article/details/83786134
 */

public class AESKeystoreUtils {

  //  private static final String ALIAS = "123";
    //  算法/模式/补码方式
    private static String TRANSFORMATION = "AES/GCM/NoPadding";
    private static byte[] encryptIv;

    /**
     * 创建秘钥
     */
    private static void createKey(String alias) {
        //获取Android KeyGenerator的实例
        //设置使用KeyGenerator的生成的密钥加密算法是AES,在 AndroidKeyStore 中保存密钥/数据
        final KeyGenerator keyGenerator;
        AlgorithmParameterSpec spec = null;
        try {
            keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
            //使用KeyGenParameterSpec.Builder 创建KeyGenParameterSpec ,传递给KeyGenerators的init方法
            //KeyGenParameterSpec 是生成的密钥的参数
            //setBlockMode保证了只有指定的block模式下可以加密,解密数据,如果使用其它的block模式,将会被拒绝。
            //使用了“AES/GCM/NoPadding”变换算法,还需要设置KeyGenParameterSpec的padding类型
            //创建一个开始和结束时间,有效范围内的密钥对才会生成。
            Calendar start = new GregorianCalendar();
            Calendar end = new GregorianCalendar();
            end.add(Calendar.YEAR, 10);//往后加十年

            //todo 高于6.0才可以使用KeyGenParameterSpec 来生成秘钥，低版本呢？
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                spec = new KeyGenParameterSpec.Builder(alias,
                        KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
                        .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                        .setCertificateNotBefore(start.getTime())
                        .setCertificateNotAfter(end.getTime())
                        .build();
            } else {
                //android6.0以下谷歌还不支持keystore的对称加解密？
//                spec = new ;

            }

            keyGenerator.init(spec);
            keyGenerator.generateKey();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchProviderException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
    }


    public static String encryptData(String needEncrypt,String alias) {

        if (!isHaveKeyStore(alias)) {
            createKey(alias);
        }

        try {
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);

            KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry) keyStore.getEntry(alias, null);

            SecretKey secretKey = secretKeyEntry.getSecretKey();

            //KeyGenParameterSpecs中设置的block模式是KeyProperties.BLOCK_MODE_GCM,所以这里只能使用这个模式解密数据。
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            //ciphers initialization vector (IV)的引用,用于解密
            encryptIv = cipher.getIV();
            return Base64.encodeToString(cipher.doFinal(needEncrypt.getBytes()), Base64.NO_WRAP);
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (UnrecoverableEntryException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            e.printStackTrace();
            return "空指针异常";
        }
        return "";
    }

    public static String decryptData(String needDecrypt,String alias) {
        if (!isHaveKeyStore(alias)) {
            createKey(alias);
        }

        try {
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);

            KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry) keyStore.getEntry(alias, null);

            SecretKey secretKey = secretKeyEntry.getSecretKey();

            //KeyGenParameterSpecs中设置的block模式是KeyProperties.BLOCK_MODE_GCM,所以这里只能使用这个模式解密数据。
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            //需要为GCMParameterSpec 指定一个认证标签长度(可以是128、120、112、104、96这个例子中我们能使用最大的128),
            // 并且用到之前的加密过程中用到的IV。
            GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, encryptIv);
            cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmParameterSpec);
            return new String(cipher.doFinal(Base64.decode(needDecrypt, Base64.NO_WRAP)));

        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnrecoverableEntryException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return "";
    }

    public static void clearKeystore(String alias) {
        try {
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.deleteEntry(alias);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 是否创建过秘钥
     *
     * @return
     */
    private static boolean isHaveKeyStore(String alias) {
        try {
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);

            KeyStore.Entry keyentry = keyStore.getEntry(alias, null);
            if (null != keyentry) {
                return true;
            }

        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (UnrecoverableEntryException e) {
            e.printStackTrace();
        }
        return false;
    }
}
import android.content.Context;
import android.os.Build;
import android.security.KeyPairGeneratorSpec;
import android.security.keystore.KeyGenParameterSpec;
import android.security.keystore.KeyProperties;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;

import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Calendar;

import javax.crypto.Cipher;
import javax.security.auth.x500.X500Principal;

/**
 * @date 2019/11/12
 * @since 2.0
 * description: 使用KeyStore+RSA非对称加密的方式
 * https://www.jianshu.com/p/06775ddf435f
 */
public class EncryptSafeUtil {

    private static final String TAG = "EncryptSafeUtil";
    private static EncryptSafeUtil encryptSafeUtilInstance = new EncryptSafeUtil();

    private KeyStore keyStore;

    private Context context;
    // 单位年
    private final int maxExpiredTime = 1000;

    private String x500PrincipalName = "CN=MyKey, O=Android Authority";

    // RSA有加密字符长度限制，所以需要分段加密
    private int rsaEncryptBlock = 244;
    private int rsaDecryptBlock = 256;

    private EncryptSafeUtil() {
    }

    public static EncryptSafeUtil getInstance() {
        return encryptSafeUtilInstance;
    }

    public void init(Context context, String x500PrincipalName) {
        this.context = context;
        this.x500PrincipalName = x500PrincipalName;
    }

    public void initKeyStore(String alias) {
        synchronized (EncryptSafeUtil.class) {
            try {
                if (null == keyStore) {
                    keyStore = KeyStore.getInstance("AndroidKeyStore");
                    keyStore.load(null);
                }
                createNewKeys(alias);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void createNewKeys(String alias) {
        if (TextUtils.isEmpty(alias)) {
            return;
        }
        try {
            if (keyStore.containsAlias(alias)) {
                return;
            }
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                // Create new key
                Calendar start = Calendar.getInstance();
                Calendar end = Calendar.getInstance();
                end.add(Calendar.YEAR, maxExpiredTime);
                KeyPairGeneratorSpec spec = new KeyPairGeneratorSpec.Builder(context)
                        .setAlias(alias)
                        .setSubject(new X500Principal(x500PrincipalName))
                        .setSerialNumber(BigInteger.ONE)
                        .setStartDate(start.getTime())
                        .setEndDate(end.getTime())
                        .build();
                KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "AndroidKeyStore");
                generator.initialize(spec);
                generator.generateKeyPair();//使用AndroidKeyStore生成密钥对
            } else {
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore");
                keyPairGenerator.initialize(
                        new KeyGenParameterSpec.Builder(
                                alias,
                                KeyProperties.PURPOSE_DECRYPT)
                                .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
                                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_PKCS1)
                                .setUserAuthenticationRequired(false)
                                .build());
                keyPairGenerator.generateKeyPair();//使用AndroidKeyStore生成密钥对
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void clearKeystore(String alias) {
        try {
            keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.deleteEntry(alias);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * RSA加密方法
     *
     * @param needEncryptWord 　需要加密的字符串
     * @param alias           　加密秘钥
     * @return
     */
    public String encryptString(String needEncryptWord, String alias) {
        if (TextUtils.isEmpty(needEncryptWord) || TextUtils.isEmpty(alias)) {
            return "";
        }
        String encryptStr = "";
        synchronized (EncryptSafeUtil.class) {
            initKeyStore(alias);
            try {
                PublicKey publicKey = keyStore.getCertificate(alias).getPublicKey();
                Cipher inCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
                inCipher.init(Cipher.ENCRYPT_MODE, publicKey);

                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                int inputLen = needEncryptWord.length();
                byte[] inputData = needEncryptWord.getBytes();
                for (int i = 0; inputLen - offSet > 0; offSet = i * rsaEncryptBlock) {
                    byte[] cache;
                    if (inputLen - offSet > rsaEncryptBlock) {
                        cache = inCipher.doFinal(inputData, offSet, rsaEncryptBlock);
                    } else {
                        cache = inCipher.doFinal(inputData, offSet, inputLen - offSet);//RSA每块加密后的密文长度都是256
                    }
                    out.write(cache, 0, cache.length);
                    ++i;
                }
                byte[] encryptedData = out.toByteArray();
                out.close();

                encryptStr = Base64.encodeToString(encryptedData, Base64.URL_SAFE);
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "in encryptString error:" + e.getMessage());
            }
        }
        return encryptStr;
    }


    /**
     * RSA解密方法
     *
     * @param needDecryptWord 需要解密的字符串
     * @param alias           key的别称
     * @return
     */
    public String decryptString(String needDecryptWord, String alias) {
        if (TextUtils.isEmpty(needDecryptWord) || TextUtils.isEmpty(alias)) {
            return "";
        }
        String decryptStr = "";
        synchronized (EncryptSafeUtil.class) {
            initKeyStore(alias);
            try {
                PrivateKey privateKey = (PrivateKey) keyStore.getKey(alias, null);
                Cipher outCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
                outCipher.init(Cipher.DECRYPT_MODE, privateKey);

                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offSet = 0;
                byte[] encryptedData = Base64.decode(needDecryptWord, Base64.URL_SAFE);//RSA密文一般都是256的倍数
                int inputLen = encryptedData.length;
                for (int i = 0; inputLen - offSet > 0; offSet = i * rsaDecryptBlock) {
                    byte[] cache;
                    if (inputLen - offSet > rsaDecryptBlock) {
                        cache = outCipher.doFinal(encryptedData, offSet, rsaDecryptBlock);
                    } else {
                        cache = outCipher.doFinal(encryptedData, offSet, inputLen - offSet);
                    }
                    out.write(cache, 0, cache.length);
                    ++i;
                }
                byte[] decryptedData = out.toByteArray();
                out.close();

                decryptStr = new String(decryptedData, 0, decryptedData.length, "UTF-8");
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "in decryptString error:" + e.getLocalizedMessage());
            }
        }
        return decryptStr;
    }
}


import android.content.Context;
import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;
import android.util.Log;

import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.Random;

import static org.junit.Assert.*;

/**
 * Instrumented test, which will execute on an Android device.
 *
 * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
 */
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {


    public static String getRandomString(int DataLen) {
        int len=DataLen /2;
        if(DataLen %2 !=0)
        {
            len=len+1;
        }
        byte [] buffer=new byte[len];
        Random random=new Random();
        random.nextBytes(buffer);
        String line=byte2Hex(buffer);
        if(DataLen %2 !=0)
        {
            line=line.substring(0, line.length()-1);
        }
        return line;
    }
    public static String byte2Hex(byte[] bytes){
        StringBuffer stringBuffer = new StringBuffer();
        String temp = null;
        for (int i=0;i<bytes.length;i++){
            temp = Integer.toHexString(bytes[i] & 0xFF).toUpperCase();
            if (temp.length()==1){
                //1得到一位的进行补0操作
                stringBuffer.append("0");
            }
            stringBuffer.append(temp);
        }
        return stringBuffer.toString();
    }


    @Test
    public void testRSAEncrypt() {
        Context appContext = InstrumentationRegistry.getTargetContext();
        System.out.println("run ok");

        {
            String data = "from android";
            String alias = "yunshouhu";
            Log.i(MainActivity.TAG, "data=" + data);
            String cipherText = EncryptSafeUtil.getInstance().encryptString(data, alias);
            Log.i(MainActivity.TAG, "cipherText=" + cipherText);
            String text = EncryptSafeUtil.getInstance().decryptString(cipherText, alias);
            Log.i(MainActivity.TAG, "text=" + text);
            EncryptSafeUtil.getInstance().clearKeystore(alias);
        }
        {
            {
                String data = getRandomString(550)+"中文";
                Log.i(MainActivity.TAG, "data=" + data);
                String alias = "yunshouhu";
                String cipherText = EncryptSafeUtil.getInstance().encryptString(data, alias);
                Log.i(MainActivity.TAG, "cipherText=" + cipherText);
                String text = EncryptSafeUtil.getInstance().decryptString(cipherText, alias);
                Log.i(MainActivity.TAG, "text=" + text);
                EncryptSafeUtil.getInstance().clearKeystore(alias);
            }
        }
    }

        @Test
        public void testAESEncrypt() {
            Context appContext = InstrumentationRegistry.getTargetContext();
            System.out.println("run ok");

            {
                String data="from android你好";
                String alias="yunshouhu002";
                String cipherText=AESKeystoreUtils.encryptData(data,alias);
                Log.i(MainActivity.TAG,"cipherText="+cipherText);
                String text=AESKeystoreUtils.decryptData(cipherText,alias);
                Log.i(MainActivity.TAG,"text="+text);
                AESKeystoreUtils.clearKeystore(alias);
            }
            {
                {
                    String data="from android你好-test";
                    String alias="yunshouhu002";
                    String cipherText=AESKeystoreUtils.encryptData(data,alias);
                    Log.i(MainActivity.TAG,"cipherText="+cipherText);
                    String text=AESKeystoreUtils.decryptData(cipherText,alias);
                    Log.i(MainActivity.TAG,"text="+text);
                    AESKeystoreUtils.clearKeystore(alias);
                }
            }

        }
}

 

yunshouhu
关注
专栏目录
Android Keystore加解密以及遇到的坑
极尽海
07-19 2298
国内使用Android Keystore加解密的应该很少吧，搜出来也基本都是Android打包时的Keystore，其实谷歌在很早之前就已经为Android提供了类似IOS的KeyChain功能，私钥存储在trustzone系统中，这个trustzone系统独立于Android系统，能做到私钥安全。 具体怎么安全，我们来了解一下加解密与签名的过程，本文不做复杂的深度解析，普通人也完全不需要了解这么透彻，想深入了解的可以google trustzon。 keystore加解密与签名的安全性其实很好理解，因为不
android 数据请求加密,通过 Android keystore 和 fingerprint 结合实现数据加密和解密
weixin_42518090的博客
05-30 685
本文目标是通过结合 Android Keystore 和 Fingerprint 来安全的对数据进行加密，并且能够通过指纹身份验证之后对数据进行解密。了解 KeystoreAndroid Keystore 系统可以在一个安全的容器中(如：借助于系统芯片中提供的可信执行环境 TEE)存储加密密钥，在我们的加密密钥进入 Keystore 之后，可以在不用导出密钥的前提下完成加密操作，Keystore ...
Android使用KeyStore对数据进行加密
热门推荐
子不语的博客
01-20 1万+
谈到 Android 安全性话题，Android Developers 官方网站给出了许多很好的建议和讲解，涵盖了存储数据、权限、网络、处理凭据、输入验证、处理用户数据、加密等方方面面 密钥的保护以及网络传输安全 应该是移动应用安全最关键的内容。Android 提供大量用来保护数据的加密算法，例如 Cipher 类中提供了 AES 和 RSA 算法，再例如安全随机数生成器 SecureRando...
Android使用KeyStore对数据进行加密的示例代码
08-31
主要介绍了Android使用KeyStore对数据进行加密的示例代码,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java的encrypt函数的语法
最新发布
weixin_32955455的博客
07-07 49
函数相关视频讲解：008_ 输出h字符_REPL_引号_括号_什么是函数数据结构与算法-栈-Go代码演示版微积分基本想法Java的encrypt函数实现方法 整体流程 首先，我们需要了解encrypt函数的功能和用法。encrypt函数是用来对数据进行加密的，它接收一个字符串作为参数，并返回一个加密后的字符串。在Ja...
Android keyStore系统存储的RSA密钥，加解密处理
qunimaode的博客
10-27 1951
Android keyStore系统存储的RSA密钥，加解密处理 Android有keysrore可以存储密钥，RSA密钥对中，公钥可以取出，私钥不能取出只能使用。本文只看23就是6.0及以上。 生产密钥对 生成密钥的参数。 spec = new KeyGenParameterSpec.Builder(mAlias, KeyProperties.PURPOSE_SIGN | KeyProperties.PURPOSE_ENCRYPT
Android KeyStore的使用
qq_43478882的博客
10-18 6041
Android KeyStore的使用
php keystore解密,如何解密keystore文件
weixin_33421065的博客
04-02 322
如果你用 geth 创建过账号「geth –datadir /path/to/data account new」，那么多半知道 keystore 文件，它通过一个 password 加密保存着账号的私钥：keystore如果我想拿到加密前的私钥怎么办？最容易想到的办法是在 MetaMask 中导入账号的时候选择通过 JSON 文件导入的方式，然后再导出私钥。不过这个方法不方便，也无法实现自动化，下...
Android 获取APK的签名秘钥keystore
Leo_Liang_jie的博客
12-20 5252
===========【获取release包签名秘钥】========= 找到release签名在项目对应的目录 1：进入签名目录：cd xxxxxxxxxxxxxxxx 2：命令：keytool -list -v -keystore xxx.jks 3：输入签名密码：xxxx enter ===========【获取debug包签名秘钥】========= debug签名默认在这个目录 cd 进去 debug签名秘钥默认是：android 1：cd 进去 2：k...
AndroidKeystore 基础使用
weixin_39948196的博客
08-06 1574
暂缓
Android Keystore System
01-04
此外，它还提供了限制密钥使用时间和方式的功能，比如要求用户对密钥使用进行认证，或者限制密钥仅能用于某些特定的加密模式。更多关于安全特性，请参考Security Features部分。 Android Keystore系统被KeyChain ...
android+密钥生成,如何在Android中使用KeyGenerator为FingerPrint API生成密钥
weixin_39985842的博客
05-28 484
看看FingerprintManagerCompat javadoc：A class that coordinates access to the fingerprint hardware.On platforms before M,this class behaves as there would be nofingerprint hardware available.看一下源代码：final ...
AndroidKeystore密钥库系统，保证本地加密算法的密钥安全性
冰码思维库
04-24 1787
1、AndroidKeystore密钥库系统介绍 AndroidKeystore系统是一个密钥库管理系统，谷歌设计这个系统的初衷应该是为了对标苹果的钥匙串KeyChain，有意思的是谷歌在Android4.0（API14）时便引入了KeyChain，但是并未提供详尽的说明文档，仅仅提供了一个API文档，网上也没有什么对它的文章，着实让人费解。话不多说，有兴趣的同学可以自行搜索，下面我来给大家介绍一...
android keystore 存储,在Android中使用KeyStore存储密钥
weixin_33653182的博客
05-26 830
我正在使用KeyStore保护我的私钥，但是在以下行中：FileOutputStream fos = ctx.openFileOutput("bs.keystore", Context.MODE_PRIVATE);被执行，我有这个异常：'java.lang.NullPointerException'.我不明白问题出在哪里。码：private Context ctx;public DataSec(C...
AndroidKeyStore的使用
honlangwu的博客
09-22 8144
密码算法使用： 关于对称加密：Google推荐使用使用的GCM模式，但是我司代码中大量使用的CBC模式，两个模式的代码，华为代码进行修改的时候，必然会考虑兼容性问题，因此把两段自己写的代码案例都贴出来供开发人员参考，便于产品的修改。1 对称加密：本地随机的密钥 方案：直接使用androidstore生成随机数，随机数做密钥1.1 AES_CBC android 实现 函数主体：public c
android keystore 存储,如何在AndroidKeystore中存储来自给定字节的密钥?
weixin_30880157的博客
05-26 365
我想将从给定字节数组生成的密钥导入Android密钥库。但也有例外。我试过下面的代码:try {byte[] keyBytes = new byte {0x31,0x32,0x33};SecretKeySpec signingKey = new SecretKeySpec(keyBytes, "HmacSHA256");KeyStore ks = KeyStore.getInstance("And...
Android密钥库（AndroidKeyStore）使用
Silicon_Valley
03-27 5930
Android 提供了特定于 Android 平台的 KeyStore 实现，称为 AndroidKeyStore，它提供了更高级的安全功能，如硬件支持、密钥链随机生成等。提示：正常我们需要对加密的数据进行本地存储，上述加密数据是ByteArray，字节数组不太适合本地存储，因此我们可以通过Base64将ByteArray数据转换为字符串进行保存，取出数据之时再做Base64解码。：可以使用 KeyStore 来存储和管理双因素身份验证所需的密钥和证书，用于提高身份验证的安全性。它接受一个字符串参数。
KeyStore存储密钥
weixin_43724742的博客
10-20 3368
KeyStore简介和用途，及KeyStore存储AES和RSA密钥的实例
Android RSA加密解密实战教程
"这篇文章主要展示了如何在Android平台上使用RSA算法进行加密和解密操作，提供了详细的示例代码供开发者参考。" 在Android开发中，RSA（Rivest-Shamir-Adleman）是一种广泛使用的非对称加密算法，它基于两个密钥：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值