diff --git a/app/src/main/java/com/example/administrator/zhapp/utils/HttpResponseListenerNoProgress.java b/app/src/main/java/com/example/administrator/zhapp/utils/HttpResponseListenerNoProgress.java new file mode 100644 index 0000000..32691b5 --- /dev/null +++ b/app/src/main/java/com/example/administrator/zhapp/utils/HttpResponseListenerNoProgress.java @@ -0,0 +1,2 @@ +package com.example.administrator.zhapp.utils;public class HttpResponseListenerNoProgress { +} diff --git a/app/src/main/java/com/example/administrator/zhapp/utils/RSAUtils.java b/app/src/main/java/com/example/administrator/zhapp/utils/RSAUtils.java new file mode 100644 index 0000000..2989353 --- /dev/null +++ b/app/src/main/java/com/example/administrator/zhapp/utils/RSAUtils.java @@ -0,0 +1,557 @@ +package com.rehome.zhdcoa.utils; + + +import android.util.Base64; +import android.util.Log; + +import java.io.ByteArrayOutputStream; +import java.security.Key; +import java.security.KeyFactory; +import java.security.KeyPair; +import java.security.KeyPairGenerator; +import java.security.interfaces.RSAPrivateKey; +import java.security.interfaces.RSAPublicKey; +import java.security.spec.PKCS8EncodedKeySpec; +import java.security.spec.X509EncodedKeySpec; +import java.util.HashMap; +import java.util.Map; + +import javax.crypto.Cipher; + + +public class RSAUtils { + + /** + * RSA算法 + */ + public static final String RSA = "RSA"; + private static final String PUBLIC_KEY = "RSAPublicKey"; + private static final String PRIVATE_KEY = "RSAPrivateKey"; + public static final int DEFAULT_KEY_SIZE = 2048;//秘钥默认长度 + + //RSA最大加密明文大小 1024位是117 算法 最大加密明文大小 = 1024(bit) / 8 - 11(byte) = 117 byte 最大加密明文大小 = 2048(bit) / 8 - 11(byte) = 245 byte + //private static final int MAX_ENCRYPT_BLOCK = 245; + private static final int MAX_ENCRYPT_BLOCK = (DEFAULT_KEY_SIZE / 8) - 11; + //RSA最大解密密文大小 1024位是128 2048位是 256 依此类推 + //private static final int MAX_DECRYPT_BLOCK = 256; + private static final int MAX_DECRYPT_BLOCK = DEFAULT_KEY_SIZE / 8; + //java默认加密填充方式 RSA 对应安卓 RSA/None/PKCS1Padding + //public static final String ECB_None_PKCS1_PADDING = "RSA"; + //安卓手机加密填充方式用 RSA/None/PKCS1Padding + public static final String ECB_None_PKCS1_PADDING = "RSA/None/PKCS1Padding"; + + + public static final String public_key = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnRh8MAqfpBZffouPsU3hToRZl3soo2ntYU4psQtc72QOvnprQ6Ua6UBY0WqemCJF/KxQ8p+vY7/r5eZ97Fw7Sq40PQTNKvyxFQuMGRAO8xTahSn2/79KViq7mVVLm2UAH8QaFmq7rJJbkCif3I1yiFMqzOF41ak231GF8eD62gr9+DFLiR1UKjv+/qXG4UjFQM6pa0cD1kAOsoYz0dSQlHFMbOaVf+VEWxSqFjKPiep6bYoViTlMRkdLqbUbHr/xk67C8lGqWO7wnB32T0+fYwnFWF952OJ9kov9oSnvOFXa+NwlAe7m2hZtFnW/NoBX1WxkQ6zTTTxJb8sRNft7qQIDAQAB"; + public static final String private_key = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCdGHwwCp+kFl9+i4+xTeFOhFmXeyijae1hTimxC1zvZA6+emtDpRrpQFjRap6YIkX8rFDyn69jv+vl5n3sXDtKrjQ9BM0q/LEVC4wZEA7zFNqFKfb/v0pWKruZVUubZQAfxBoWaruskluQKJ/cjXKIUyrM4XjVqTbfUYXx4PraCv34MUuJHVQqO/7+pcbhSMVAzqlrRwPWQA6yhjPR1JCUcUxs5pV/5URbFKoWMo+J6nptihWJOUxGR0uptRsev/GTrsLyUapY7vCcHfZPT59jCcVYX3nY4n2Si/2hKe84Vdr43CUB7ubaFm0Wdb82gFfVbGRDrNNNPElvyxE1+3upAgMBAAECggEAOcphHRc7ZRSp6paStMoOoWDEyJoQ+BSms84aPjwM4y/u0JmeThM11CrMwbU0RIkPMAV//dFKpypaMIfbOREw6qctJmlWxIKS7kgCMNIcfcXlIWmvqKOJSCuOObkMCE1ef1EXu7ll8vUgY+bd8DfEs2vM6fPkDM2kFwEZgkKeZYlkFcLLy8V701seLtNzbPaqAUa44S6m0DVH7gojad8+Ni/XsdNzSrd8Y2930M8LVZoOTLrwskJaF2v/WvjM3blOtHxLqDfXfD4uRm12b1SNzPx2djlL6vNptwbpYAtPOYol8W0LxJH2AHbTrUFv/KJdyuD4NVGSnGpYtWzD7QQetQKBgQDLqfaiq0uHQerAc3M30pOZSDF8PtiBd1jdqFoOVhuADkp4LPXm54s5evEi2r3tl4x8cAvUo6WaxDlG3IFO0POLcZY+Xf2sMhwMAxiwWqLVRGirjr6QAfnmWAToqqyh8brxNti4MC3X/yudrd6x/VJ1lQ3Pooiihf4Ir74QuY7wqwKBgQDFdwbFou07bQmxCElgC5MF78Aevn5JzsniGU2RhpxG7ajf2T9n6AjtVfvYLy6iYsfLm6RGC2uofBjMgL920ePXBSDv0fk1UEVoR/vCtspyCLBVXELdSS5DCnux1F15vKAJZQyODGyEv0d8h97qKRaq14EW75e9vPx4ahxXgaiM+wKBgGE0AonK9aZdmJw3veMDtvxuj2e8WvsXqitIwYqcIE3zBCntU4PcOP+7JMG84u816JAvrgXUASMnyip+7ZxfcA26rbmghIUd+XLmO29YIuVk3AwdeegjeVEt61Hcu74jMFUWF0N5gzfXCsscA/Cxdhy2gjv6V/oxt3gP4Mf8uDM3AoGAJMVhcXRBkQtg/qJ4Z3ZATp6yvAblJYFofr4Pf8X9XAftpqGh+QtwfiHA4CUJHhwe8H9vO8vspFdXlt1yygGT1/qQg5gqPA9SnXSqITxAvrN3gq3HlcWG490T462UKpNBif5TNDCEFMQ536q9jAVSv0WaOFctfpuuuA2qcXEnnfkCgYEAuFWzis7ICtcZTr8CZOC7FeVL6URzI1akwRlHDHRUrNRCTf47HGUG9bCC6N+v6ex7TD2XlaB0g3U9XXjYRyk9T2AWfgzPvgvw7H+tI9r+9yyDlUbb2pvaKdVQIgCnJ6Hg7Qw7MuwzjEiXLF7HMy5CFnrVnHAjYrNe1Gqgo0v3rsY="; + public static final String public_key_client = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAu0jZXvlRCBOX5R2wW7a+A6dciQD2F2DQqOOaVyPGH1fQxBdVn/HfgiBYXPDIodaSSTDcl1rjlepUiAZjyTpzieZgDo6txy5ncB1ts85frc0DF08zn+zztj4g9zIU7Q8pzxYJ+2wI1XcNzt0eaWBCU7DZKjjp5iRTuKNcLJ5VLe0w8PfvG+AwqGDN+j+523V79o81pdhBJ5hzWhdkzO62X2Va7EjcQ9kpDNDsafqXzhXEyf7LiEsyQkDWzWCZuZN7DQhKriJepfrFqCqlkUHtjd6LSwloEqxYdrfTHuKxxLEUJF+051vrEafwAVM2Sg65nqWbPI11E2DBbr3wSNVYKQIDAQAB"; + public static final String private_key_client= "MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQC7SNle+VEIE5flHbBbtr4Dp1yJAPYXYNCo45pXI8YfV9DEF1Wf8d+CIFhc8Mih1pJJMNyXWuOV6lSIBmPJOnOJ5mAOjq3HLmdwHW2zzl+tzQMXTzOf7PO2PiD3MhTtDynPFgn7bAjVdw3O3R5pYEJTsNkqOOnmJFO4o1wsnlUt7TDw9+8b4DCoYM36P7nbdXv2jzWl2EEnmHNaF2TM7rZfZVrsSNxD2SkM0Oxp+pfOFcTJ/suISzJCQNbNYJm5k3sNCEquIl6l+sWoKqWRQe2N3otLCWgSrFh2t9Me4rHEsRQkX7TnW+sRp/ABUzZKDrmepZs8jXUTYMFuvfBI1VgpAgMBAAECggEAL7KfAcw3cfojfkuwZbtF64JNU+s1wcB7g/frj/PheowP9FEJEqI0TVzVhF4iiu0t9owGMloIil7Sxo3yDgbf9CgDINH/ujG8UFZ+YQPXZFlJRz95o2piq3BpTuunXrS07jPruOfL3CnlD2FLZIUKf2wT8ufp0h5AYE7io85zXS2SvzlWuchA1bzGCGZc88zr5VWcbDGHXWG7PDd8VgEEb69UUP6H0IWWEAeHwOeqZ9sJHcvhwx93ecQ+evXHztRYouJ0WzQOOEKKHgID+ImcpYpyAbSeWfacyOHx6UVu+2fL88jyhhz20OQLVCBp2MzIHPPez0l/LJ/OveeKC3lLvQKBgQDNl+Kj7DfhcjvzLBML6tAE73tiGt6QbMf9frVq4J+oAM9tW862WsZgAAOSkkG+fUuIF0FmvQ4mRPs8R2s4etC5n5G3wEbLPJruF2yEngONI8bI9i+yzx/xVl3Pru85QOBvpxpxCPx2uxK/LzE5PfnWPqRwQ7+BiLMVLigM/bn+nwKBgQDpM8+9CQ2S/RA6qao6Sr3LiLATA0y0ShjEiii2ZkCxgTyl004xhSxj45ijkFmJRqUix7yt/CGZQq3JxnrWAEH1Y0r/AM8F7sTtKu37fLyCoVpQ4HlyyCCVVLvTExOZYsf8lGLJB2DOJGKK5V69uvOLqc8zmsPSSbVlvAC+6ZHcNwKBgDWXIMmv2kUW3M+fLnvNwll2/0dsT5V/9YV7UNjCInvNckRESRa5hLojZsr++sonqNeZkD+yigypsH9e8nDvepbYJEisgweZDZ2AV5YeBjj1GWzq1zYZzW7AH4XySIM5CQexnC/Yss5UJyfUqlUMdaJGA+ELl9CxDFU6CdCRFrlrAoGAR2tVuNgX7ydPnBewCZAwVjAzdG8zQ5fZw/9n/oyMTZB96W8waFwXvzPJ4HXp5e/bzS4Mq+AmzhAstznxDq8fhC53nmc5/+AjMVtPbRDDjuIpjdFhgHSn/fPoXflerEAjbUhohJac4CUmhNFAVaz2v5Qu3+gLBtEKG/Ea7V0NDbsCgYAocw/DFV5hAyQHyVwPNtsSd/vF+iGSyJJxqBPXW36fLNzdkoZL8TNGWeuyTloZbsXBorYESTX+1522xAFr7FcQpoQRjEOAuloqc5+C03D0fSrdczbxyHQMVTvsdFbfKWaQO4EjDrZqFA50h3rhY3ZosT8IS5npZQ7ifR3B1DCfdQ=="; + public static final String public_key_local = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/lhQRyFMV5LLJz9jFjY+ZW/79wEuujDJjy8YxlxqfST+FUUOytH46fLRd5m4s4Nj7L03hssz0H0M1pKiUzUzp6ulSC8GH2/uZzBq47agre9bW0A+Uu0IiCwfOc0J1L1UlLm/wWRGW0Sw51OHYAs99irjhxdGFOVv/mS9FzzxmBRFOwUXFD8iXyEKI8xkteyHGniKRwBYoWR32kQw7H/Mnpamo1fCrHA6Dg55CBeIEkg2oyPGKzvhkPVopJzj9zukW8w2F0iR5ll0QBl7XzGyy3EHmIsYsod3LSIh1g5A2zsscJ0ouorKGLwY1LK06a34JTkYz5p7lx6Nn6589Re8GwIDAQAB"; + public static final String private_key_local = "MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQD+WFBHIUxXkssnP2MWNj5lb/v3AS66MMmPLxjGXGp9JP4VRQ7K0fjp8tF3mbizg2PsvTeGyzPQfQzWkqJTNTOnq6VILwYfb+5nMGrjtqCt71tbQD5S7QiILB85zQnUvVSUub/BZEZbRLDnU4dgCz32KuOHF0YU5W/+ZL0XPPGYFEU7BRcUPyJfIQojzGS17IcaeIpHAFihZHfaRDDsf8yelqajV8KscDoODnkIF4gSSDajI8YrO+GQ9WiknOP3O6RbzDYXSJHmWXRAGXtfMbLLcQeYixiyh3ctIiHWDkDbOyxwnSi6isoYvBjUsrTprfglORjPmnuXHo2frnz1F7wbAgMBAAECggEAakyCkJfMDjWdjjOht+DHxyE8TwlBfDNzqdHnKs/o+ZCCWGVaP03uF+iRvsiSNwRMuN6D3GQErbf1q5/xE5GCmyrTkw2EI5NmMd48bhsfoFIO/l4lLgc+r5qxGjklSLIwLVBMYgkElpRo0uVICM3qAX3/RbBma8lQOyPjG1kvJ31L/xYN4DbfOfumqs3Eb06ZNvPEP0BnbbVFp6NiOcBvLipQxrhnMob5MDyPWEjcBeV/IssK3ZvrzjsqF1Ckz8KNUKGfDq4DHM7YzkLBySDIiOZHSBfimzc8fxtDFZpMOOBbEZJ0sGlTeftv5Zd0KHWD0OBWBeSHeVFRBc5RCPO38QKBgQD/rPC5Jr2Sgp3tKrRyEztYZrce0ecYvsxYZRgQpSxLF+rd8Z8ftH/MHPEdnYZjLWFPDrd+R3eEEr5B2t2sfKUWE/PA97RvSp/Uqv0xKoetX8JopeZ6X/3PRb9bQFWRe2dPBSA5mKx8MIOIhfr2qjdepDF+Lejn4pCFDSs8BLpPbQKBgQD+qvDlusQ1IvBi19DnKqx3iLvgHFHYb/GcrFzqfQZewGZLH7yoBo4zXZLT2Np+DW7K8IC3JOLNhLrvD1V8+bmOwW84Foo62Gvm1GPm8nxbgTCqg+ns5bV0xoHXdN1v4dAgeOBqYrIFkmSfxpB4usij8yFMZkN7PNZ3KwQYqZYcpwKBgQDS+qKqJo3ImIA5dUPx3mzaRehWRl+sy8VULBfvpF0omlP1Ua09PHU4uak+Bv8eWBQ0aLCCQ/cbxVu6fCDwdOrFjTFXyw/Zxnqdw3urVq0fJCYItN27nfqTT7rYUf5KTsqxKkmtPY8X6/Ced/DgGxYVwugUd036C7u2D2fd3wjfAQKBgQCfHkduAofde3sfByFrjmo8NZ7NpGQvC6K29asIiB2Wzjgb8DR797yZs3muC+xYniP/gM2roMxlBO2XuMj9UTrzS0Emlk6//cFNdJ8HCbNRqSKzJ8DdV5lM4Ur3R/mjkj/sShpN3mTEvndIrVRPWsVKSvsfNTYsphKKWsIwdqVoOQKBgQD5ibg09UHs0dHiaOn0lKsUFb25q+ylu4NLIU6gh/xi7sJ2huRA2gElPwkUsCIzH+/TTiIdvs1WuoBCvvCWL6a7xchN1+nve2fw4ohNHWupcTNWX1k1pNFHXjhtaUMes7zTTy6wBDbkbM7yTQLtB8/VMzMpuzg6UZPw3Hv8sIOz+w=="; + public static final String public_key_mqtt = "MIIEIjANBgkqhkiG9w0BAQEFAAOCBA8AMIIECgKCBAEAujmJWv1QTJU1uS/t0Tj0ms9dPuYtZeuxCCAvc93/6JvxAON6UyfniL4hScOzwDqR74GsOtYC5O1JNi4VGn4XU6XKt30o+/cCJeSaynmcVRBnkbjpo4pvE/97//GEwHbhPSsHRv2GmURx/wEZKGhlAceMu3xMs1slhD2gmGlfoZTdMULUN7xIbN5wgwZbcGs+XD+eaGEkE6xOyJdthKnsoYq+7lsfl0668231374zIDMSYCkcES5v86jr0HG4TVYymBbD33/WAJ0ISyBP+LMboasw62QoVrwPYXkWIqfiFFHwpi/TqyjJef8bM4bUuW2vqfFCMRZb23NKIseSvjgJu62FlQAPFgw8U5/i1yRGyFJPryJP0dJS07uv5k+J5iSKabvjp0RWkVLwgUzctQKjJhx+cE9bOPXgAGp7dczumjMPlOVm7AGEsAAlDNHNcDksKssy91kl3tkkj987/0P534TehtKvZ43W2XoOSyA0nPxfb/hxb6cLo3D1OD9Favc5WkSUgnYS8Kc+wwOPpUl8eveGLWjbdd8tFGpq8jW2Nrrk584zqu6OqgE9BqHC4NwnMkd1ZmwVBC7aUB+BuVgKxb+lRXRzoYOeCYYdn4Rg0yEdSJcCTwEEwJqouAD/eCkj2KVpz2lTr1zut8w4oDwk9BYe/9R5fz9/yE+M06MAG60ys4Ac0IpfERQP8VP3a+JuTZGPvan/CSq4nGdvd/+R+aZHcQUJDXk1YzSPZFezrLIVZQe0u0HbIIfPhLHmEwCAXzhM1Ise4xC8XHOytlJw3drkNAsJN9sZ9UePLZMEkggLYgzsgSZ11tRgObA/OXPW4/fd71RO/MZmH9DLv7blCkLomTKinKDiO7MsQvjIQaDKgOVX8Db8UvVcolZLHy48c6vUbJFVXRo2ds/1MK5sgDBNGzNTX/QkPuQS+IDnh4g4edbU0tfwTzkcawHShMza+QQfcHRu5hgpurGv4CApcVWIZn49T/ElJMbSSQczbF6f08piXs8hlyUYBhFjdQJNp3Imuii2c1M10rOGn1PHR0yIay6+L1toDn6ASJksY1FCNSkzpv5utykEKf0Hq2+HX0Wi1Umdl/tndqBVXygSgi4SSu/j5iZtSnjwb1DxQKvO5LLNxxdtEJLsEpQii5LlWr7MjkcsR7zHhzzkqWIAsIbaiwuasMcRkYbAjYFcIH4mSZCTACvsTDxm+hB0GxVmGEfEgknphVm0Yqa7/NXcz9bL856ez5IemmiavfntBS8uhet3m4FYa0FolJF0YdlJa0LCXW/QQYa/PltBFx9xY9nveEp08f+DXUPzJ+0puX3qxLIMyazTfM4mWgxxPmMQOFTNwGwtNGMP6Ncbd6V4oQIDAQAB"; + public static final String private_key_mqtt = "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"; + + + public static byte[] decryptBASE64(String key) throws Exception { + return Base64.decode(key, Base64.NO_WRAP); + //return Base64.decode(key); + } + + public static String encryptBASE64(byte[] key) throws Exception { + return Base64.encodeToString(key, Base64.NO_WRAP); + //return Base64.encode(key); + } + + public static String decryptBASE64Str(String encryptString) { + try { + byte[] decodeByte = decryptBASE64(encryptString); + return new String(decryptByPrivateKeyLongText(decodeByte, private_key),java.nio.charset.StandardCharsets.UTF_8); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String decryptBASE64StrClient(String encryptString) { + try { + byte[] decodeByte = decryptBASE64(encryptString); + return new String(decryptByPrivateKeyLongText(decodeByte, private_key_client),java.nio.charset.StandardCharsets.UTF_8); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String decryptBASE64StrByPublic(String encryptString) { + try { + byte[] decodeByte = decryptBASE64(encryptString); + return new String(decryptByPublicKeyLongText(decodeByte, public_key),java.nio.charset.StandardCharsets.UTF_8); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String decryptBASE64StrLocal(String encryptString) { + try { + byte[] decodeByte = decryptBASE64(encryptString); + return new String(decryptByPrivateKeyLongText(decodeByte, private_key_local),java.nio.charset.StandardCharsets.UTF_8); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String decryptBASE64StrMqtt(String encryptString) { + try { + byte[] decodeByte = decryptBASE64(encryptString); + return new String(decryptByPrivateKey(decodeByte, private_key_mqtt),java.nio.charset.StandardCharsets.UTF_8); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String encryptBASE64Str(String text) { + try { + return encryptBASE64(encryptByPublicKeyLongText(text.getBytes( java.nio.charset.StandardCharsets.UTF_8), public_key)); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String encryptBASE64StrClient(String text) { + try { + return encryptBASE64(encryptByPublicKeyLongText(text.getBytes( java.nio.charset.StandardCharsets.UTF_8), public_key_client)); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String encryptBASE64StrLocal(String text) { + try { + return encryptBASE64(encryptByPublicKeyLongText(text.getBytes( java.nio.charset.StandardCharsets.UTF_8), public_key_local)); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + public static String encryptBASE64StrMqtt(String text) { + try { + return encryptBASE64(encryptByPublicKey(text.getBytes( java.nio.charset.StandardCharsets.UTF_8), public_key_mqtt)); + } catch (Exception e) { + e.printStackTrace(); + } + return ""; + } + + + /** + * 解密
+ * 用私钥解密 + * + * @param data + * @param key + * @return + * @throws Exception + */ + public static byte[] decryptByPrivateKey(byte[] data, String key) + throws Exception { + // 对密钥解密 + byte[] keyBytes = decryptBASE64(key); + // 取得私钥 + PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec); + // 对数据解密 + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + cipher.init(Cipher.DECRYPT_MODE, privateKey); + return cipher.doFinal(data); + } + + /** + * 私钥分段解密 + * @param encryptedData + * @param privateKey + * @return + * @throws Exception + */ + public static byte[] decryptByPrivateKeyLongText(byte[] encryptedData, String privateKey) throws Exception { + + byte[] keyBytes = decryptBASE64(privateKey); + PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + cipher.init(Cipher.DECRYPT_MODE, privateK); + + int inputLen = encryptedData.length; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + int offSet = 0; + byte[] cache; + int i = 0; + // 对数据分段解密 + while (inputLen - offSet > 0) { + if (inputLen - offSet > MAX_DECRYPT_BLOCK) { + + cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); + } else { + cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); + } + out.write(cache, 0, cache.length); + i++; + offSet = i * MAX_DECRYPT_BLOCK; + } + byte[] decryptedData = out.toByteArray(); + out.close(); + return decryptedData; + } + + /** + * 解密
+ * 用公钥解密 + * + * @param data + * @param key + * @return + * @throws Exception + */ + public static byte[] decryptByPublicKey(byte[] data, String key) + throws Exception { + // 对密钥解密 + byte[] keyBytes = decryptBASE64(key); + // 取得公钥 + X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + Key publicKey = keyFactory.generatePublic(x509KeySpec); + // 对数据解密 + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + cipher.init(Cipher.DECRYPT_MODE, publicKey); + return cipher.doFinal(data); + } + + /** + * 用公钥分段解密 + * @param encryptedData + * @param publicKey + * @return + * @throws Exception + */ + public static byte[] decryptByPublicKeyLongText(byte[] encryptedData, String publicKey) throws Exception { + + byte[] keyBytes = decryptBASE64(publicKey); + + X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); + + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + + Key publicK = keyFactory.generatePublic(x509KeySpec); + + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + + cipher.init(Cipher.DECRYPT_MODE, publicK); + + int inputLen = encryptedData.length; + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + + int offSet = 0; + + byte[] cache; + + int i = 0; + + // 对数据分段解密 + + while (inputLen - offSet > 0) { + + if (inputLen - offSet > MAX_DECRYPT_BLOCK) { + + cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK); + + } else { + + cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet); + + } + + out.write(cache, 0, cache.length); + + i++; + + offSet = i * MAX_DECRYPT_BLOCK; + + } + + byte[] decryptedData = out.toByteArray(); + + out.close(); + + return decryptedData; + + } + + /** + * 加密
+ * 用公钥加密 + * + * @param data + * @param key + * @return + * @throws Exception + */ + public static byte[] encryptByPublicKey(byte[] data, String key) + throws Exception { + // 对公钥解密 + byte[] keyBytes = decryptBASE64(key); + // 取得公钥 + X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + Key publicKey = keyFactory.generatePublic(x509KeySpec); + // 对数据加密 + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + cipher.init(Cipher.ENCRYPT_MODE, publicKey); + return cipher.doFinal(data); + } + + /** + * 用公钥分段加密 + * @param data + * @param publicKey + * @return + * @throws Exception + */ + public static byte[] encryptByPublicKeyLongText(byte[] data, String publicKey) throws Exception { + + byte[] keyBytes = decryptBASE64(publicKey); + + X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); + + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + + Key publicK = keyFactory.generatePublic(x509KeySpec); + + // 对数据加密 + + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + + cipher.init(Cipher.ENCRYPT_MODE, publicK); + + int inputLen = data.length; + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + + int offSet = 0; + + byte[] cache; + + int i = 0; + + // 对数据分段加密 + + while (inputLen - offSet > 0) { + + if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { + + cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); + + } else { + + cache = cipher.doFinal(data, offSet, inputLen - offSet); + + } + + out.write(cache, 0, cache.length); + + i++; + + offSet = i * MAX_ENCRYPT_BLOCK; + + } + + byte[] encryptedData = out.toByteArray(); + + out.close(); + + return encryptedData; + + } + + /** + * 加密
+ * 用私钥加密 + * + * @param data + * @param key + * @return + * @throws Exception + */ + public static byte[] encryptByPrivateKey(byte[] data, String key) + throws Exception { + // 对密钥解密 + byte[] keyBytes = decryptBASE64(key); + // 取得私钥 + PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec); + // 对数据加密 + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + cipher.init(Cipher.ENCRYPT_MODE, privateKey); + return cipher.doFinal(data); + } + + /** + * 用私钥分段加密 + * @param data + * @param privateKey + * @return + * @throws Exception + */ + public static byte[] encryptByPrivateKeyLongText(byte[] data, String privateKey) throws Exception { + + byte[] keyBytes = decryptBASE64(privateKey); + + PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); + + KeyFactory keyFactory = KeyFactory.getInstance(RSA); + + Key privateK = keyFactory.generatePrivate(pkcs8KeySpec); + + Cipher cipher = Cipher.getInstance(ECB_None_PKCS1_PADDING); + + cipher.init(Cipher.ENCRYPT_MODE, privateK); + + int inputLen = data.length; + + ByteArrayOutputStream out = new ByteArrayOutputStream(); + + int offSet = 0; + + byte[] cache; + + int i = 0; + + // 对数据分段加密 + + while (inputLen - offSet > 0) { + + if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { + + cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK); + + } else { + + cache = cipher.doFinal(data, offSet, inputLen - offSet); + + } + + out.write(cache, 0, cache.length); + + i++; + + offSet = i * MAX_ENCRYPT_BLOCK; + + } + + byte[] encryptedData = out.toByteArray(); + + out.close(); + + return encryptedData; + + } + + /** + * 取得私钥 + * + * @param keyMap + * @return + * @throws Exception + */ + public static String getPrivateKey(Map keyMap) + throws Exception { + Key key = (Key) keyMap.get(PRIVATE_KEY); + + return encryptBASE64(key.getEncoded()); + } + + /** + * 取得公钥 + * + * @param keyMap + * @return + * @throws Exception + */ + public static String getPublicKey(Map keyMap) + throws Exception { + Key key = (Key) keyMap.get(PUBLIC_KEY); + return encryptBASE64(key.getEncoded()); + } + + /** + * 初始化密钥 + * + * @return + * @throws Exception + */ + public static Map initKey() throws Exception { + KeyPairGenerator keyPairGen = KeyPairGenerator + .getInstance(RSA); + keyPairGen.initialize(2048); + KeyPair keyPair = keyPairGen.generateKeyPair(); + // 公钥 + RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); + // 私钥 + RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); + Map keyMap = new HashMap(2); + keyMap.put(PUBLIC_KEY, publicKey); + keyMap.put(PRIVATE_KEY, privateKey); + return keyMap; + } + + public static void rsa() { + try { + Map key = RSAUtils.initKey(); + String publicKey = RSAUtils.getPublicKey(key); + String privateKey = RSAUtils.getPrivateKey(key); + String signbypub = RSAUtils.encryptBASE64(RSAUtils.encryptByPublicKey("wenfei".getBytes(), RSAUtils.public_key)); + byte[] decodeByte = RSAUtils.decryptBASE64(signbypub); + String ecodeStr = new String(RSAUtils.decryptByPrivateKey(decodeByte, RSAUtils.private_key)); + Log.i("app", "-----------公钥------------"); + Log.i("app", publicKey); + Log.i("app", "-----------私钥------------"); + Log.i("app", privateKey); + Log.i("app", "-----------公钥加密------------"); + Log.i("app", signbypub); + Log.i("app", "-----------私钥解密------------"); + Log.i("app", ecodeStr); + + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void main(String[] args) { + try { + Map key = RSAUtils.initKey(); + String publicKey = RSAUtils.getPublicKey(key); + String privateKey = RSAUtils.getPrivateKey(key); + String signbypub = RSAUtils.encryptBASE64(RSAUtils.encryptByPublicKey("wenfei".getBytes(), RSAUtils.public_key)); + byte[] decodeByte = RSAUtils.decryptBASE64(signbypub); + String ecodeStr = new String(RSAUtils.decryptByPrivateKey(decodeByte, RSAUtils.private_key)); + Log.i("app", "-----------公钥------------"); + Log.i("app", publicKey); + Log.i("app", "-----------私钥------------"); + Log.i("app", privateKey); + Log.i("app", "-----------公钥加密------------"); + Log.i("app", signbypub); + Log.i("app", "-----------私钥解密------------"); + Log.i("app", ecodeStr); + + } catch (Exception e) { + e.printStackTrace(); + } + } +} \ No newline at end of file