From 90f15b4acac10531b5a3135323d033d40bb19dfa Mon Sep 17 00:00:00 2001 From: chiteroman <98092901+chiteroman@users.noreply.github.com> Date: Fri, 22 Dec 2023 01:16:58 +0100 Subject: [PATCH] v3.5 --- app/build.gradle | 6 +- .../chiteroman/bootloaderspoofer/Keybox.java | 242 ++++++++ .../chiteroman/bootloaderspoofer/Xposed.java | 521 +++++------------- 3 files changed, 384 insertions(+), 385 deletions(-) create mode 100644 app/src/main/java/es/chiteroman/bootloaderspoofer/Keybox.java diff --git a/app/build.gradle b/app/build.gradle index 7c74453..94fe6e0 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -11,8 +11,8 @@ android { applicationId "es.chiteroman.bootloaderspoofer" minSdk 26 targetSdk 34 - versionCode 34 - versionName '3.4' + versionCode 35 + versionName '3.5' multiDexEnabled false } @@ -34,5 +34,5 @@ android { dependencies { compileOnly 'de.robv.android.xposed:api:82' - implementation 'org.bouncycastle:bcpkix-jdk18on:1.77' + implementation 'com.madgag.spongycastle:bcpkix-jdk15on:1.58.0.0' } diff --git a/app/src/main/java/es/chiteroman/bootloaderspoofer/Keybox.java b/app/src/main/java/es/chiteroman/bootloaderspoofer/Keybox.java new file mode 100644 index 0000000..2fc1f3e --- /dev/null +++ b/app/src/main/java/es/chiteroman/bootloaderspoofer/Keybox.java @@ -0,0 +1,242 @@ +package es.chiteroman.bootloaderspoofer; + +public class Keybox { + public static final String XML = """ + + + 1 + + + + -----BEGIN EC PRIVATE KEY----- + MHcCAQEEIA2Pc+RjAdMyqaCpctIuSyCGhsPnTHPeOxhM7QmGb1gNoAoGCCqGSM49 + AwEHoUQDQgAEWu/pudQWIK+TPC7f9dftyxq5te8xMChNHYALeeiB6zk8laiG9zu9 + cae9EY763/thIoZQXQTVQK43+QHcKnOetQ== + -----END EC PRIVATE KEY----- + + + 3 + + -----BEGIN CERTIFICATE----- + MIICJTCCAaugAwIBAgIKEJl1VCCDF2mHUzAKBggqhkjOPQQDAjApMRkwFwYDVQQF + ExA4YWJlMWM3NWRjMWNkNTk5MQwwCgYDVQQMDANURUUwHhcNMTgwNDE4MjEzMzQ5 + WhcNMjgwNDE1MjEzMzQ5WjApMRkwFwYDVQQFExA2MGYyMjlmMTlmY2EzYTA0MQww + CgYDVQQMDANURUUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARa7+m51BYgr5M8 + Lt/11+3LGrm17zEwKE0dgAt56IHrOTyVqIb3O71xp70Rjvrf+2EihlBdBNVArjf5 + Adwqc561o4G6MIG3MB0GA1UdDgQWBBSriAVmksHYWuCRLlDvR47MzfcUfDAfBgNV + HSMEGDAWgBSQv/MlEz9XMxBFdPp9W+RNB1737TAPBgNVHRMBAf8EBTADAQH/MA4G + A1UdDwEB/wQEAwICBDBUBgNVHR8ETTBLMEmgR6BFhkNodHRwczovL2FuZHJvaWQu + Z29vZ2xlYXBpcy5jb20vYXR0ZXN0YXRpb24vY3JsLzEwOTk3NTU0MjA4MzE3Njk4 + NzUzMAoGCCqGSM49BAMCA2gAMGUCMQDx5cRqI58iDdXLDkD0rvh1fjOSmejV5NCH + +KX5A2mZLzxxy8QkW3szHck0qvarVK0CMGDi3tjaKLiM3rPHyAJmltRDIvLZejwz + R+0oP0cs/vld5xBZSoXbvjCPe39IQryn7Q== + -----END CERTIFICATE----- + + + -----BEGIN CERTIFICATE----- + MIID0TCCAbmgAwIBAgIKA4gmZ2BliZaFkTANBgkqhkiG9w0BAQsFADAbMRkwFwYD + VQQFExBmOTIwMDllODUzYjZiMDQ1MB4XDTE4MDQxODIxMTQ1NloXDTI4MDQxNTIx + MTQ1NlowKTEZMBcGA1UEBRMQOGFiZTFjNzVkYzFjZDU5OTEMMAoGA1UEDAwDVEVF + MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEiejPFIryi9AYM9zV6pGpIFaVpPgdB+zI + jJSPgDcZkeDL5Y9Sie0/aAopayrp5UYs+zxRKHIZjAXS9HWOzGg/PIxBa1Fl0tRz + HPLGiW1BIrc8pEK+6AJ429QTJoSn4h/No4G2MIGzMB0GA1UdDgQWBBSQv/MlEz9X + MxBFdPp9W+RNB1737TAfBgNVHSMEGDAWgBQ2YeEAfIgFCVGLRGxH/xpMyepPEjAP + BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwICBDBQBgNVHR8ESTBHMEWgQ6BB + hj9odHRwczovL2FuZHJvaWQuZ29vZ2xlYXBpcy5jb20vYXR0ZXN0YXRpb24vY3Js + L0U4RkExOTYzMTREMkZBMTgwDQYJKoZIhvcNAQELBQADggIBAAt4xKMpMK52papq + k/QhULlXzaJrYLfLOmvOo1oP4urFcZD7Usk7G2HNoJM2qg3qgjawcUrAov7ZNekl + Uc8ZSozY3yJiHGGNRNezXDDPnj+v+XAjE5I46iG3WoZvMYaa0GK5qNMf9v1/UScN + D517vhSJIuFjsZjZOHbS83dit7JOoJ/e+5WnLdgdvMpixgkvXrp6Y9DlBFY5c2FY + 9i1MsPi9WDpylxAigB8g4bcZ0/fsMhLTUiGuenaS4c6TrKaqWBBcTtYdpECNJ+bE + FowbW9nxOaI88deIxnldvFpms9XZw/amAx8y2hwoC5kLzhAAcjIidn2oKiTQr1zI + C2iVnFWyE8z+T7s//KKfzYLFm5h9YdW7n87j3PkRW5zZOVUzg2a5n/ME8qbCdYQV + Qe2ouog4Z/Tu/dwocEeH1jQaiAjqtliiLyJD0XaFqxvGf49IyRFuxq5eK5EAx2Cv + GoJLFqL2jIvxdSyOxd58s6I9EnomS6hFWsmwNsuVKxFtnI+Okv1mLm4C8qwVxx6f + SQBUJTtUmK/hliL42cjtAfHqVyYM4xV7F8MP10ncEB0hG2yua5g5Y4Ds3wcVIp5Z + USgFL9I0raZrb91fJPYetHbb/rrSRp/h805f7Ilf2cApZenzlgcf8JzZ2PuKxWsA + a/UNhoh2zVkWkGJr00lp8Df1RYXM + -----END CERTIFICATE----- + + + -----BEGIN CERTIFICATE----- + MIIFYDCCA0igAwIBAgIJAOj6GWMU0voYMA0GCSqGSIb3DQEBCwUAMBsxGTAXBgNV + BAUTEGY5MjAwOWU4NTNiNmIwNDUwHhcNMTYwNTI2MTYyODUyWhcNMjYwNTI0MTYy + ODUyWjAbMRkwFwYDVQQFExBmOTIwMDllODUzYjZiMDQ1MIICIjANBgkqhkiG9w0B + AQEFAAOCAg8AMIICCgKCAgEAr7bHgiuxpwHsK7Qui8xUFmOr75gvMsd/dTEDDJdS + Sxtf6An7xyqpRR90PL2abxM1dEqlXnf2tqw1Ne4Xwl5jlRfdnJLmN0pTy/4lj4/7 + tv0Sk3iiKkypnEUtR6WfMgH0QZfKHM1+di+y9TFRtv6y//0rb+T+W8a9nsNL/ggj + nar86461qO0rOs2cXjp3kOG1FEJ5MVmFmBGtnrKpa73XpXyTqRxB/M0n1n/W9nGq + C4FSYa04T6N5RIZGBN2z2MT5IKGbFlbC8UrW0DxW7AYImQQcHtGl/m00QLVWutHQ + oVJYnFPlXTcHYvASLu+RhhsbDmxMgJJ0mcDpvsC4PjvB+TxywElgS70vE0XmLD+O + JtvsBslHZvPBKCOdT0MS+tgSOIfga+z1Z1g7+DVagf7quvmag8jfPioyKvxnK/Eg + sTUVi2ghzq8wm27ud/mIM7AY2qEORR8Go3TVB4HzWQgpZrt3i5MIlCaY504LzSRi + igHCzAPlHws+W0rB5N+er5/2pJKnfBSDiCiFAVtCLOZ7gLiMm0jhO2B6tUXHI/+M + RPjy02i59lINMRRev56GKtcd9qO/0kUJWdZTdA2XoS82ixPvZtXQpUpuL12ab+9E + aDK8Z4RHJYYfCT3Q5vNAXaiWQ+8PTWm2QgBR/bkwSWc+NpUFgNPN9PvQi8WEg5Um + AGMCAwEAAaOBpjCBozAdBgNVHQ4EFgQUNmHhAHyIBQlRi0RsR/8aTMnqTxIwHwYD + VR0jBBgwFoAUNmHhAHyIBQlRi0RsR/8aTMnqTxIwDwYDVR0TAQH/BAUwAwEB/zAO + BgNVHQ8BAf8EBAMCAYYwQAYDVR0fBDkwNzA1oDOgMYYvaHR0cHM6Ly9hbmRyb2lk + Lmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC8wDQYJKoZIhvcNAQELBQAD + ggIBACDIw41L3KlXG0aMiS//cqrG+EShHUGo8HNsw30W1kJtjn6UBwRM6jnmiwfB + Pb8VA91chb2vssAtX2zbTvqBJ9+LBPGCdw/E53Rbf86qhxKaiAHOjpvAy5Y3m00m + qC0w/Zwvju1twb4vhLaJ5NkUJYsUS7rmJKHHBnETLi8GFqiEsqTWpG/6ibYCv7rY + DBJDcR9W62BW9jfIoBQcxUCUJouMPH25lLNcDc1ssqvC2v7iUgI9LeoM1sNovqPm + QUiG9rHli1vXxzCyaMTjwftkJLkf6724DFhuKug2jITV0QkXvaJWF4nUaHOTNA4u + JU9WDvZLI1j83A+/xnAJUucIv/zGJ1AMH2boHqF8CY16LpsYgBt6tKxxWH00XcyD + CdW2KlBCeqbQPcsFmWyWugxdcekhYsAWyoSf818NUsZdBWBaR/OukXrNLfkQ79Iy + ZohZbvabO/X+MVT3rriAoKc8oE2Uws6DF+60PV7/WIPjNvXySdqspImSN78mflxD + qwLqRBYkA3I75qppLGG9rp7UCdRjxMl8ZDBld+7yvHVgt1cVzJx9xnyGCC23Uaic + MDSXYrB4I4WHXPGjxhZuCuPBLTdOLU8YRvMYdEvYebWHMpvwGCF6bAx3JBpIeOQ1 + wDB5y0USicV3YgYGmi+NZfhA4URSh77Yd6uuJOJENRaNVTzk + -----END CERTIFICATE----- + + + + + + -----BEGIN RSA PRIVATE KEY----- + MIIG4gIBAAKCAYEA46CnsChjrTJK+xBGJmPn06WJ6ofOxPGdLVgnX5IZcQMY19hx + NFMWtLAidMWY63h2U6KEL0eTYTA1Y51H/oKEPCPf/beyEzN54zz/cozLlPgngQuV + TNEaHFa8uV3f5xnQvFDMxW9LELNS9R75zlULjitPL0uND/TALuBnnQW4dPxorGP9 + b06UAh3ONgAcHlsSh755oLZe/R6uEI/cw6DEUB6PoQDLPT/kFHreqpJ7ZjzU3wVe + LEYMi/g5c2vk3Zn3VHv10ge1MfbmOKgA1n01Vu0wXJS038EizXBUdfuKGyIXBXL+ + /4/K87p0oL3PkwdAfmWDOM55XaMRMeIZ/6FWsVvTZqyzPbzcN1EImhMvOsTAnDzW + QkoyFcI8P83OF24JvA1VQbvIqdKWPTBg9sFfRFj9m3xr/q7EBjg+VHk9KXPv7/C4 + szfJSwxp1rb859bgmHP3BbDDYRlhX+r+HV0j5ZkLSbx1J10qHuIcg9lavySwATai + 11x3lccjtRTuqmsnAgMBAAECggGAJzPpDW63VAHgZgL0gfIc4BeXfBvtoX+XOVMA + XPZViWAmLC5ruL5Cn9Xh6UiKwKsbfeX0bAwgttFNsJ1K4+toiM8I6bJ0adgoutkr + iXf0K/DdJN1w1i0BGTZbBHXFdRC+IWCtE6fKPtMTi4HNNhrxhYex+IxDfCcD3k7p + qWJt1UAPavlBkaTv2rl1ZVl5fkTjGRvV6Lbf/yoEgne0ZsDObpoE1I7FcgQJ7PkI + VkoqFH6PjuVmxas+x/B1PIqtfPjiC5O7WpKujXVaj+Ft7kpf0GP5gRR92eTWouW4 + gAO1bHzFzkHIFQafqgYThU5xIZzwNzzRZ9uNj3Yw2xcaBa9QFKFtOuAPDzwEU62N + FOKl6yi0B2fwpWcW6tDuRskThe2QV7TBeQmzueXFZ3EQQ8bIqkXUNp/cVVEFKOf0 + f5Hq77g1QtgejAQXzb0kKm/f+ibTy6gZofAnXJ2ANtwSXtsTd9Uu/cyY53L7X7Wu + kg3wI68uEGkwAoMuxMi/PdlmkwMpAoHBAP9is4nU388qzzpeiZnpv/BQbNtQWY/o + 4cskGOrBPtySmQlzdvWiOI9TShM8uHYmdZryqSU9OqPCBcvDrOIabkrcKDVdy5RV + oYunOIfXDi3UQC6gzBhm4k0POo5HN8DmQGWMlqVCoEGOQwjLVLY/WNFJJHLtNG2z + xHNPp5bdEU91C8/vCoXHLY0R6IUtW53hvVcrXr5yZyxDjpbaSWXt4G8CGKWG1/i1 + oTfPg6lpIeu33a2CnRdmbDh4nTMxoNWqjQKBwQDkLNtZUmcQA4tXYMNtppOGx1xl + ZGgMwvHKVfQmc5N6kePAz2raTf7iG1TYFIGwe/T1KWV1Ur/fA3HAb3Z2+Ryc/VMM + LEXH8+gM/XcyhBmpMnnwXbBFbbnu2iERUnWb+kBLHWXdhK9kCXYJrQVtu46IsDbd + qkyQnAuHRUbYroI6lzG3JNO2H55mS5GuWOEW/3VwmTJH+Wc8DQhfUfQt9IeNtZ3Q + ppg2zKrivUPUDbEFVrDQVFJrFafAHbFWk0x1+YMCgcA6qaNwD7PxVHYRhFG7RxRN + 0UuP/R71jZsAHKSUmBsmc44vu5QhzEeNtKYZUSNWEHOHSiJMaYokv5axPZtivIuF + KpkZ2RfAVQMsnxa/LUkWgeDUVR9Mo6Vr6gmbUQSfjMRSDz8zauCA7nq7dGlbC6YN + PO3gcFhQsrB3hF6Mqu8k/0/dTZ1vKVdvRiPRI6Ad3hKuCUpUGNdWNZZ1VGLzxPZ+ + yU58B0No39/OgB5QNdQS30NObehDzcUiG6KQdd/p9KkCgcEAzyZSNXN0EbvGAxvc + EG5MPO49Weef9wX80X7bWxVObNaJ+H/WOD7bCZdanZlwbDL9Hp3oeG0ZuHO+D8Ch + wj1C1tu9S63d5DvxDeoHDxuS2GL1BV1pLH8DcG8j2kAMegDl4cvcsRFG0gEs4nfs + F8VRD5M7HF8Bh7/DT5l7SjiUDnE5N1X9xrhJ7ADrT2dtYp2llwXd+i3YpVIHqdIT + Zq07a1HY5pZ4VjfVZGgDbj7H2VrsxxXmhUVxuB684yZzIh/VAoG/OabMPA2YFqtf + 7rXDWwqT1pwMYOEupL9tO5kAky3Zz9zE/WKdfmIvGjZQxz64QhmtwGKm0VFkYAzT + LP1gZ+C4b6cRHLXNcZ7Z344Skz66B/Z9Z0/9VW8aJ/4M5zqcjfaGjbFjELd1KuDh + wjRT3LLWcjLZ1w/IJy6r+rqq0d7A26o0B5UfykqudVvjJ+eOq3ozhlzgdzrrhewb + jTU2mUlIrlv0ESD2M22HHTP8TD8DVvw8UkGsOsQ7bzWSRNALiqE= + -----END RSA PRIVATE KEY----- + + + 3 + + -----BEGIN CERTIFICATE----- + MIIFETCCAvmgAwIBAgIKEjZQKHdTV5RDkjANBgkqhkiG9w0BAQsFADApMRkwFwYD + VQQFExA4YWJlMWM3NWRjMWNkNTk5MQwwCgYDVQQMDANURUUwHhcNMTgwNDE4MjEz + MzM3WhcNMjgwNDE1MjEzMzM3WjApMRkwFwYDVQQFExA2MGYyMjlmMTlmY2EzYTA0 + MQwwCgYDVQQMDANURUUwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDj + oKewKGOtMkr7EEYmY+fTpYnqh87E8Z0tWCdfkhlxAxjX2HE0Uxa0sCJ0xZjreHZT + ooQvR5NhMDVjnUf+goQ8I9/9t7ITM3njPP9yjMuU+CeBC5VM0RocVry5Xd/nGdC8 + UMzFb0sQs1L1HvnOVQuOK08vS40P9MAu4GedBbh0/GisY/1vTpQCHc42ABweWxKH + vnmgtl79Hq4Qj9zDoMRQHo+hAMs9P+QUet6qkntmPNTfBV4sRgyL+Dlza+TdmfdU + e/XSB7Ux9uY4qADWfTVW7TBclLTfwSLNcFR1+4obIhcFcv7/j8rzunSgvc+TB0B+ + ZYM4znldoxEx4hn/oVaxW9NmrLM9vNw3UQiaEy86xMCcPNZCSjIVwjw/zc4Xbgm8 + DVVBu8ip0pY9MGD2wV9EWP2bfGv+rsQGOD5UeT0pc+/v8LizN8lLDGnWtvzn1uCY + c/cFsMNhGWFf6v4dXSPlmQtJvHUnXSoe4hyD2Vq/JLABNqLXXHeVxyO1FO6qaycC + AwEAAaOBujCBtzAdBgNVHQ4EFgQUmbr9kYSB6NcHyyQQCTzuCX8sZQIwHwYDVR0j + BBgwFoAUTPvLka8NVNWeiOjUoimnhWNHDLUwDwYDVR0TAQH/BAUwAwEB/zAOBgNV + HQ8BAf8EBAMCAgQwVAYDVR0fBE0wSzBJoEegRYZDaHR0cHM6Ly9hbmRyb2lkLmdv + b2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC8xMjM2NTAyODc3NTM1Nzk0NDM5 + MjANBgkqhkiG9w0BAQsFAAOCAgEAqVwxi6MFNhvQ3VqvxPwlDniWwd2o/6wPrk3J + xtGbYtTi6e++aWDnR8o6SGCsbN+A3bSI2Va2xvkLiS0j3F19SfVdknXEUG9p5Z7M + bQ4m1dTH4Ch32r+YVde4UEZmkiMizirrAVct9jkruIPXNrzOHH5rOkMmREdVFcBk + g7V67NpXF6JcR5+RNw+mOmZO0MMPE/HviUUkAMXQYPmMhtcFYuYhB4Y6w3+LVWAw + kKJ2UBxZjEYih4Db5iWwZDhC1lO6aCNEaC/xcVIIQt0rdwlQ/F9Uz3Zkb+tTGYP7 + CNB8cxugqlBPphVqIxZcngcPSI2f5/QQ1yV4G7os3p3grKDihXQtI3iyeO0grmkc + DzopKfo6WdTl9jcpb0LVUMeVbSXJ9Dfrk3moFeueBOxSMDAWMXHP4Ma4MSBQwViS + e4h6D2uL0VefBw8vKhXTCb1VESlGuncNu9PrBF1uFqO6pxUvjjzmijCgrvVbGWiM + YPWsToiK40S3DpKL6dI4b3QJM2hvqfhboceD2CO4+i96iR3ODo3ongsGOe2L9UC2 + V98HvnCy+LClFrk23Laq5WJkVZq2bS5RAfkc4fzf6DGfNpMp/Pj+z12E+FlPBIuQ + oeDdHD87ogaMbMug/VrJRPMSO5pDFg9GUQmGjCwI0nFDQcrnWfNxm//3bK/iAmgZ + yeUhJXg= + -----END CERTIFICATE----- + + + -----BEGIN CERTIFICATE----- + MIIFfzCCA2egAwIBAgIKA4gmZ2BliZaFkDANBgkqhkiG9w0BAQsFADAbMRkwFwYD + VQQFExBmOTIwMDllODUzYjZiMDQ1MB4XDTE4MDQxODIxMTQzOFoXDTI4MDQxNTIx + MTQzOFowKTEZMBcGA1UEBRMQOGFiZTFjNzVkYzFjZDU5OTEMMAoGA1UEDAwDVEVF + MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAz/1/+QlEgDhajc+ZONg6 + RbbqK3bd5H3QILvCXWB/wWbd/V3cLrdztMh3XM/j34tp5buUFCqQ3TS+JcUSnXe2 + 3Ldc9LCGktAVEYXqTp6JnomS/ZHwx0lDccqBaynghCODeT6okPjFdhnPHJ/smFAC + 5AtjW6N31IrPi+uJw9hMGew6viG5L4guXqO7wDP+gNYLdmETwYuH7kMzgOYYWHZv + 6bH4iK4v8QmkC5PX8fyqrQ6Ag59HX0rZP22mGtKGt+12xJeTWc9Nfz+13FbRCIXp + WNYARfVCgPI/vpuRvowFnqQMFF8hP0JEdIgP0VZsk39pwLhDH9ASnjwYjq9+j2OX + 8VIP+ajFl0nRVunjzsrQFTyN4SprkxBUiP8oLl9cYzgd08xRo8xI+3K3mdoK3EVx + ufII0KEYckauhjCuGcuztXHrJEucdv5h8gV/jBeXjp1mV7pSPLl4VH0KUqIpWgL/ + wZT6surci/AT9fN7GW34Nnshwx8yDSUzjpQ1bAclvFlKnQX6neevo2SDAGaW+pA/ + A4tTF6w4Emf7mnpj5LoXD9bx/5ONmSYRMP2E9+yaJiwX1czqeTj9HzSwm1PIm6qB + s+Kjil+Cbgp1EG/gQKsqsKDs3AgQs6JJQxlh3R56tqC0HAy+CTJ5S4rno3TkWim4 + r1xCat30Ee3+6DPRtIMObFECAwEAAaOBtjCBszAdBgNVHQ4EFgQUTPvLka8NVNWe + iOjUoimnhWNHDLUwHwYDVR0jBBgwFoAUNmHhAHyIBQlRi0RsR/8aTMnqTxIwDwYD + VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAgQwUAYDVR0fBEkwRzBFoEOgQYY/ + aHR0cHM6Ly9hbmRyb2lkLmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC9F + OEZBMTk2MzE0RDJGQTE4MA0GCSqGSIb3DQEBCwUAA4ICAQCNewTykPmU/1E9zUDi + uhz4V/KzPfPlFNjwzg9eRRXoL0IFkk+8sIl8mdn+hBFkMLU3R3bjTajnVkBdymi+ + fduwzBD5cdUuVsU/iEbDswg2DQxoj/eOTjNOSMoa9IQXkT9mDriNvDlBKWEQFkDT + +2E4kcu00GUQLEnm3tY7uX7EcCIZB9n/j0HMX2kyebB3mwa2NyWtdcR10Bw6XWXu + ZTuWPxe+km+x66OqBb5Tq4IMJ5vsqvG5QeureSOBP7BbRQ3z3RBGjIkz485aTdf/ + Gv3ikbOlEeIfv0tOQTYn4ft2kBdizyuhGRMgqRJcjo5bM4LU2nraJfXVbO7Plnnr + 6GXLHrHU/G1E/sN2fH4O3Zk/In5Y/y5rMR4WCncPgtO2a8bd7jgpQcU5keCX2anW + TtOKtQCCNKn+RBVZAFb7bEEjVEqKBOYqnsiHbml69zX/nnDNFZs5Ek2hQbwGCwVs + 7Eo4bgwW9mx2WTcRKaIZLk/aJ0pAzQvkPg8ojpJHSZY15AsxgS5k3rWcKIvqXaxk + xX0o5ub3V7aV45Sk+/dTV/tgQ9KpXVcNwi19a4knJo/9cbVpBVOYxVf4HZV2ds0l + yVPbnJDGKEHtuyO0puIMqMwP8lm8xN6clnVuG+4RuOTmzFN8u9AvlDL92imSyX1v + 9CyCxsjOYp45mn6Um/+dbYjSZw== + -----END CERTIFICATE----- + + + -----BEGIN CERTIFICATE----- + MIIFYDCCA0igAwIBAgIJAOj6GWMU0voYMA0GCSqGSIb3DQEBCwUAMBsxGTAXBgNV + BAUTEGY5MjAwOWU4NTNiNmIwNDUwHhcNMTYwNTI2MTYyODUyWhcNMjYwNTI0MTYy + ODUyWjAbMRkwFwYDVQQFExBmOTIwMDllODUzYjZiMDQ1MIICIjANBgkqhkiG9w0B + AQEFAAOCAg8AMIICCgKCAgEAr7bHgiuxpwHsK7Qui8xUFmOr75gvMsd/dTEDDJdS + Sxtf6An7xyqpRR90PL2abxM1dEqlXnf2tqw1Ne4Xwl5jlRfdnJLmN0pTy/4lj4/7 + tv0Sk3iiKkypnEUtR6WfMgH0QZfKHM1+di+y9TFRtv6y//0rb+T+W8a9nsNL/ggj + nar86461qO0rOs2cXjp3kOG1FEJ5MVmFmBGtnrKpa73XpXyTqRxB/M0n1n/W9nGq + C4FSYa04T6N5RIZGBN2z2MT5IKGbFlbC8UrW0DxW7AYImQQcHtGl/m00QLVWutHQ + oVJYnFPlXTcHYvASLu+RhhsbDmxMgJJ0mcDpvsC4PjvB+TxywElgS70vE0XmLD+O + JtvsBslHZvPBKCOdT0MS+tgSOIfga+z1Z1g7+DVagf7quvmag8jfPioyKvxnK/Eg + sTUVi2ghzq8wm27ud/mIM7AY2qEORR8Go3TVB4HzWQgpZrt3i5MIlCaY504LzSRi + igHCzAPlHws+W0rB5N+er5/2pJKnfBSDiCiFAVtCLOZ7gLiMm0jhO2B6tUXHI/+M + RPjy02i59lINMRRev56GKtcd9qO/0kUJWdZTdA2XoS82ixPvZtXQpUpuL12ab+9E + aDK8Z4RHJYYfCT3Q5vNAXaiWQ+8PTWm2QgBR/bkwSWc+NpUFgNPN9PvQi8WEg5Um + AGMCAwEAAaOBpjCBozAdBgNVHQ4EFgQUNmHhAHyIBQlRi0RsR/8aTMnqTxIwHwYD + VR0jBBgwFoAUNmHhAHyIBQlRi0RsR/8aTMnqTxIwDwYDVR0TAQH/BAUwAwEB/zAO + BgNVHQ8BAf8EBAMCAYYwQAYDVR0fBDkwNzA1oDOgMYYvaHR0cHM6Ly9hbmRyb2lk + Lmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC8wDQYJKoZIhvcNAQELBQAD + ggIBACDIw41L3KlXG0aMiS//cqrG+EShHUGo8HNsw30W1kJtjn6UBwRM6jnmiwfB + Pb8VA91chb2vssAtX2zbTvqBJ9+LBPGCdw/E53Rbf86qhxKaiAHOjpvAy5Y3m00m + qC0w/Zwvju1twb4vhLaJ5NkUJYsUS7rmJKHHBnETLi8GFqiEsqTWpG/6ibYCv7rY + DBJDcR9W62BW9jfIoBQcxUCUJouMPH25lLNcDc1ssqvC2v7iUgI9LeoM1sNovqPm + QUiG9rHli1vXxzCyaMTjwftkJLkf6724DFhuKug2jITV0QkXvaJWF4nUaHOTNA4u + JU9WDvZLI1j83A+/xnAJUucIv/zGJ1AMH2boHqF8CY16LpsYgBt6tKxxWH00XcyD + CdW2KlBCeqbQPcsFmWyWugxdcekhYsAWyoSf818NUsZdBWBaR/OukXrNLfkQ79Iy + ZohZbvabO/X+MVT3rriAoKc8oE2Uws6DF+60PV7/WIPjNvXySdqspImSN78mflxD + qwLqRBYkA3I75qppLGG9rp7UCdRjxMl8ZDBld+7yvHVgt1cVzJx9xnyGCC23Uaic + MDSXYrB4I4WHXPGjxhZuCuPBLTdOLU8YRvMYdEvYebWHMpvwGCF6bAx3JBpIeOQ1 + wDB5y0USicV3YgYGmi+NZfhA4URSh77Yd6uuJOJENRaNVTzk + -----END CERTIFICATE----- + + + + + """; +} diff --git a/app/src/main/java/es/chiteroman/bootloaderspoofer/Xposed.java b/app/src/main/java/es/chiteroman/bootloaderspoofer/Xposed.java index 85da20e..5aef47a 100644 --- a/app/src/main/java/es/chiteroman/bootloaderspoofer/Xposed.java +++ b/app/src/main/java/es/chiteroman/bootloaderspoofer/Xposed.java @@ -3,53 +3,52 @@ import android.security.keystore.KeyGenParameterSpec; import android.security.keystore.KeyProperties; -import org.bouncycastle.asn1.ASN1Boolean; -import org.bouncycastle.asn1.ASN1Encodable; -import org.bouncycastle.asn1.ASN1Enumerated; -import org.bouncycastle.asn1.ASN1Integer; -import org.bouncycastle.asn1.ASN1Null; -import org.bouncycastle.asn1.ASN1ObjectIdentifier; -import org.bouncycastle.asn1.ASN1OctetString; -import org.bouncycastle.asn1.ASN1Sequence; -import org.bouncycastle.asn1.DERNull; -import org.bouncycastle.asn1.DEROctetString; -import org.bouncycastle.asn1.DLSequence; -import org.bouncycastle.asn1.DLSet; -import org.bouncycastle.asn1.DLTaggedObject; -import org.bouncycastle.asn1.x500.X500Name; -import org.bouncycastle.asn1.x509.Extension; -import org.bouncycastle.cert.X509CertificateHolder; -import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter; -import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder; -import org.bouncycastle.openssl.PEMKeyPair; -import org.bouncycastle.openssl.PEMParser; -import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter; -import org.bouncycastle.operator.ContentSigner; -import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder; +import org.spongycastle.asn1.ASN1Boolean; +import org.spongycastle.asn1.ASN1Encodable; +import org.spongycastle.asn1.ASN1Enumerated; +import org.spongycastle.asn1.ASN1Integer; +import org.spongycastle.asn1.ASN1ObjectIdentifier; +import org.spongycastle.asn1.ASN1OctetString; +import org.spongycastle.asn1.ASN1Sequence; +import org.spongycastle.asn1.DERNull; +import org.spongycastle.asn1.DEROctetString; +import org.spongycastle.asn1.DERSequence; +import org.spongycastle.asn1.DERSet; +import org.spongycastle.asn1.DERTaggedObject; +import org.spongycastle.asn1.x500.X500Name; +import org.spongycastle.asn1.x509.Extension; +import org.spongycastle.asn1.x509.KeyUsage; +import org.spongycastle.cert.X509CertificateHolder; +import org.spongycastle.cert.jcajce.JcaX509CertificateConverter; +import org.spongycastle.cert.jcajce.JcaX509v3CertificateBuilder; +import org.spongycastle.openssl.PEMKeyPair; +import org.spongycastle.openssl.PEMParser; +import org.spongycastle.openssl.jcajce.JcaPEMKeyConverter; +import org.spongycastle.operator.ContentSigner; +import org.spongycastle.operator.jcajce.JcaContentSignerBuilder; +import org.spongycastle.util.io.pem.PemObject; +import org.spongycastle.util.io.pem.PemReader; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import java.io.ByteArrayInputStream; -import java.io.IOException; import java.io.StringReader; import java.math.BigInteger; -import java.nio.charset.StandardCharsets; import java.security.KeyPair; import java.security.KeyPairGenerator; +import java.security.KeyPairGeneratorSpi; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.KeyStoreSpi; -import java.security.NoSuchAlgorithmException; -import java.security.NoSuchProviderException; import java.security.SecureRandom; import java.security.cert.Certificate; -import java.security.cert.CertificateException; -import java.util.ArrayDeque; import java.util.Arrays; import java.util.Date; -import java.util.Deque; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Map; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; @@ -62,101 +61,79 @@ import de.robv.android.xposed.callbacks.XC_LoadPackage; public final class Xposed implements IXposedHookLoadPackage { - private static final SecureRandom random = new SecureRandom(); - private static final Deque EC_CERTS = new ArrayDeque<>(3); - private static final Deque RSA_CERTS = new ArrayDeque<>(3); - private static byte[] attestationChallengeBytes = new byte[0]; - private static KeyPair EC_KEYPAIR, RSA_KEYPAIR; - private static String MODULE_PATH; - - private static void loadKeyBox() { + private static final Map map = new HashMap<>(); + private static byte[] attestationChallengeBytes = new byte[1]; + private static KeyPair keyPair; + + static { + int numberOfCerts = 0; + try { - EC_CERTS.clear(); - RSA_CERTS.clear(); - - DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); - DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); - - Document doc = dBuilder.parse(new ByteArrayInputStream(KEYBOX.getBytes(StandardCharsets.UTF_8))); - doc.getDocumentElement().normalize(); - - Element rootElement = doc.getDocumentElement(); - - int numberOfKeyboxes = Integer.parseInt(rootElement.getElementsByTagName("NumberOfKeyboxes").item(0).getTextContent()); - XposedBridge.log("Number of Keyboxes: " + numberOfKeyboxes); - - NodeList keyboxList = rootElement.getElementsByTagName("Keybox"); - for (int i = 0; i < keyboxList.getLength(); i++) { - Node keyboxNode = keyboxList.item(i); - if (keyboxNode.getNodeType() == Node.ELEMENT_NODE) { - Element keyboxElement = (Element) keyboxNode; - String deviceId = keyboxElement.getAttribute("DeviceID"); - XposedBridge.log("Device ID: " + deviceId); - - NodeList keyList = keyboxElement.getElementsByTagName("Key"); - for (int j = 0; j < keyList.getLength(); j++) { - Node keyNode = keyList.item(j); - if (keyNode.getNodeType() == Node.ELEMENT_NODE) { - Element keyElement = (Element) keyNode; - - String algorithm = keyElement.getAttribute("algorithm"); - - Element privateKeyElement = (Element) keyElement.getElementsByTagName("PrivateKey").item(0); - String privateKey = privateKeyElement.getTextContent(); - - if ("ecdsa".equals(algorithm)) EC_KEYPAIR = parsePrivateKey(privateKey); - else if ("rsa".equals(algorithm)) - RSA_KEYPAIR = parsePrivateKey(privateKey); - - NodeList certList = keyElement.getElementsByTagName("Certificate"); - for (int k = 0; k < certList.getLength(); k++) { - Node certNode = certList.item(k); - if (certNode.getNodeType() == Node.ELEMENT_NODE) { - Element certElement = (Element) certNode; - String certValue = certElement.getTextContent(); - - if ("ecdsa".equals(algorithm)) - EC_CERTS.add(parseCert(certValue)); - else if ("rsa".equals(algorithm)) - RSA_CERTS.add(parseCert(certValue)); - } - } - } + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + DocumentBuilder builder = factory.newDocumentBuilder(); + Document document = builder.parse(new ByteArrayInputStream(Keybox.XML.getBytes())); + + NodeList keyList = document.getElementsByTagName("Key"); + + for (int i = 0; i < keyList.getLength(); i++) { + Node keyNode = keyList.item(i); + if (keyNode.getNodeType() == Node.ELEMENT_NODE) { + Element keyElement = (Element) keyNode; + + String privateKeyPEM = keyElement.getElementsByTagName("PrivateKey").item(0).getTextContent(); + KeyPair keyPair = parseKeyPair(privateKeyPEM); + + NodeList certificateNodes = keyElement.getElementsByTagName("Certificate"); + + int certs = certificateNodes.getLength(); + + Certificate[] certificates = new Certificate[certs]; + + for (int j = 0; j < certs; j++) { + String certificatePEM = certificateNodes.item(j).getTextContent(); + Certificate certificate = parseCert(certificatePEM); + certificates[j] = certificate; } + + map.put(keyPair, certificates); + + numberOfCerts += certs; } } } catch (Exception e) { - XposedBridge.log("[BootloaderSpoofer] ERROR: " + e); - throw new RuntimeException(); + throw new RuntimeException(e); } - } - private static KeyPair parsePrivateKey(String key) throws IOException { - key = key.trim(); + XposedBridge.log("[BootloaderSpoofer] Loaded " + map.size() + " keys!"); + XposedBridge.log("[BootloaderSpoofer] Loaded " + numberOfCerts + " certificates!"); + } - PEMParser parser = new PEMParser(new StringReader(key)); - Object o = parser.readObject(); - parser.close(); + private static KeyPair parseKeyPair(String key) throws Exception { + Object object; + try (PEMParser parser = new PEMParser(new StringReader(key))) { + object = parser.readObject(); + } - PEMKeyPair pemKeyPair = (PEMKeyPair) o; + PEMKeyPair pemKeyPair = (PEMKeyPair) object; return new JcaPEMKeyConverter().getKeyPair(pemKeyPair); } - private static Certificate parseCert(String cert) throws IOException, CertificateException { - cert = cert.trim(); - - PEMParser parser = new PEMParser(new StringReader(cert)); - Object o = parser.readObject(); - parser.close(); + private static Certificate parseCert(String cert) throws Exception { + PemObject pemObject; + try (PemReader reader = new PemReader(new StringReader(cert))) { + pemObject = reader.readPemObject(); + } - X509CertificateHolder holder = (X509CertificateHolder) o; + X509CertificateHolder holder = new X509CertificateHolder(pemObject.getContent()); return new JcaX509CertificateConverter().getCertificate(holder); } private static Extension addHackedExtension() { try { + SecureRandom random = new SecureRandom(); + byte[] bytes1 = new byte[32]; byte[] bytes2 = new byte[32]; @@ -165,54 +142,54 @@ private static Extension addHackedExtension() { ASN1Encodable[] rootOfTrustEncodables = {new DEROctetString(bytes1), ASN1Boolean.TRUE, new ASN1Enumerated(0), new DEROctetString(bytes2)}; - ASN1Sequence rootOfTrustSeq = new DLSequence(rootOfTrustEncodables); + ASN1Sequence rootOfTrustSeq = new DERSequence(rootOfTrustEncodables); ASN1Integer[] purposesArray = {new ASN1Integer(2), new ASN1Integer(3)}; - DLSet Apurpose = new DLSet(purposesArray); - ASN1Integer Aalgorithm = new ASN1Integer(3); - ASN1Integer AkeySize = new ASN1Integer(256); - ASN1Integer AecCurve = new ASN1Integer(1); - ASN1Null AnoAuthRequired = DERNull.INSTANCE; - ASN1Integer AosVersion = new ASN1Integer(140000); - ASN1Integer AosPatchLevel = new ASN1Integer(202312); - ASN1Integer AvendorPatchLevel = new ASN1Integer(20231217); - ASN1Integer AbootPatchLevel = new ASN1Integer(20231217); - - ASN1Integer AcreationDateTime = new ASN1Integer(System.currentTimeMillis()); - ASN1Integer Aorigin = new ASN1Integer(0); - - var purpose = new DLTaggedObject(true, 1, Apurpose); - var algorithm = new DLTaggedObject(true, 2, Aalgorithm); - var keySize = new DLTaggedObject(true, 3, AkeySize); - var ecCurve = new DLTaggedObject(true, 10, AecCurve); - var noAuthRequired = new DLTaggedObject(true, 503, AnoAuthRequired); - var creationDateTime = new DLTaggedObject(true, 701, AcreationDateTime); - var origin = new DLTaggedObject(true, 702, Aorigin); - var rootOfTrust = new DLTaggedObject(true, 704, rootOfTrustSeq); - var osVersion = new DLTaggedObject(true, 705, AosVersion); - var osPatchLevel = new DLTaggedObject(true, 706, AosPatchLevel); - var vendorPatchLevel = new DLTaggedObject(true, 718, AvendorPatchLevel); - var bootPatchLevel = new DLTaggedObject(true, 719, AbootPatchLevel); - - ASN1Encodable[] teeEnforcedEncodables = {purpose, algorithm, keySize, ecCurve, noAuthRequired, creationDateTime, origin, rootOfTrust, osVersion, osPatchLevel, vendorPatchLevel, bootPatchLevel}; - - ASN1Integer attestationVersion = new ASN1Integer(4); + ASN1Encodable[] digests = {new ASN1Integer(4)}; + + var Apurpose = new DERSet(purposesArray); + var Aalgorithm = new ASN1Integer(3); + var AkeySize = new ASN1Integer(256); + var Adigest = new DERSet(digests); + var AecCurve = new ASN1Integer(1); + var AnoAuthRequired = DERNull.INSTANCE; + var AosVersion = new ASN1Integer(140000); + var AosPatchLevel = new ASN1Integer(202312); + + var AcreationDateTime = new ASN1Integer(System.currentTimeMillis()); + var Aorigin = new ASN1Integer(0); + + var purpose = new DERTaggedObject(true, 1, Apurpose); + var algorithm = new DERTaggedObject(true, 2, Aalgorithm); + var keySize = new DERTaggedObject(true, 3, AkeySize); + var digest = new DERTaggedObject(true, 5, Adigest); + var ecCurve = new DERTaggedObject(true, 10, AecCurve); + var noAuthRequired = new DERTaggedObject(true, 503, AnoAuthRequired); + var creationDateTime = new DERTaggedObject(true, 701, AcreationDateTime); + var origin = new DERTaggedObject(true, 702, Aorigin); + var rootOfTrust = new DERTaggedObject(true, 704, rootOfTrustSeq); + var osVersion = new DERTaggedObject(true, 705, AosVersion); + var osPatchLevel = new DERTaggedObject(true, 706, AosPatchLevel); + + ASN1Encodable[] teeEnforcedEncodables = {purpose, algorithm, keySize, digest, ecCurve, noAuthRequired, creationDateTime, origin, rootOfTrust, osVersion, osPatchLevel}; + + ASN1Integer attestationVersion = new ASN1Integer(200); ASN1Enumerated attestationSecurityLevel = new ASN1Enumerated(2); - ASN1Integer keymasterVersion = new ASN1Integer(41); + ASN1Integer keymasterVersion = new ASN1Integer(200); ASN1Enumerated keymasterSecurityLevel = new ASN1Enumerated(2); ASN1OctetString attestationChallenge = new DEROctetString(attestationChallengeBytes); ASN1OctetString uniqueId = new DEROctetString("".getBytes()); - ASN1Sequence softwareEnforced = new DLSequence(); - ASN1Sequence teeEnforced = new DLSequence(teeEnforcedEncodables); + ASN1Sequence softwareEnforced = new DERSequence(); + ASN1Sequence teeEnforced = new DERSequence(teeEnforcedEncodables); ASN1Encodable[] keyDescriptionEncodables = {attestationVersion, attestationSecurityLevel, keymasterVersion, keymasterSecurityLevel, attestationChallenge, uniqueId, softwareEnforced, teeEnforced}; - ASN1Sequence keyDescriptionHackSeq = new DLSequence(keyDescriptionEncodables); + ASN1Sequence keyDescriptionHackSeq = new DERSequence(keyDescriptionEncodables); ASN1OctetString keyDescriptionOctetStr = new DEROctetString(keyDescriptionHackSeq); - return new Extension(new ASN1ObjectIdentifier("1.3.6.1.4.1.11129.2.1.17"), true, keyDescriptionOctetStr); + return new Extension(new ASN1ObjectIdentifier("1.3.6.1.4.1.11129.2.1.17"), false, keyDescriptionOctetStr); } catch (Exception e) { XposedBridge.log("[BootloaderSpoofer] Error create extensions: " + e); @@ -223,11 +200,16 @@ private static Extension addHackedExtension() { private static Certificate hackLeafCert() throws Exception { - var certBuilder = new JcaX509v3CertificateBuilder(new X500Name("CN=chiteroman"), new BigInteger(128, random), new Date(System.currentTimeMillis()), new Date(System.currentTimeMillis() + 365L * 24 * 60 * 60 * 1000), new X500Name("CN=Android Keystore Key"), RSA_KEYPAIR.getPublic()); + SecureRandom random = new SecureRandom(); + + var certBuilder = new JcaX509v3CertificateBuilder(new X500Name("CN=chiteroman"), new BigInteger(128, random), new Date(System.currentTimeMillis()), new Date(System.currentTimeMillis() + 365L * 24 * 60 * 60 * 1000), new X500Name("CN=Android Keystore Key"), keyPair.getPublic()); + + KeyUsage keyUsage = new KeyUsage(KeyUsage.keyCertSign); + certBuilder.addExtension(Extension.keyUsage, true, keyUsage); certBuilder.addExtension(addHackedExtension()); - ContentSigner contentSigner = new JcaContentSignerBuilder("SHA256withRSA").build(RSA_KEYPAIR.getPrivate()); + ContentSigner contentSigner = new JcaContentSignerBuilder("SHA256withECDSA").build(keyPair.getPrivate()); X509CertificateHolder certHolder = certBuilder.build(contentSigner); @@ -235,43 +217,40 @@ private static Certificate hackLeafCert() throws Exception { } @Override - public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) { + public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable { - loadKeyBox(); + for (KeyPair pair : map.keySet()) { + if (KeyProperties.KEY_ALGORITHM_EC.equals(pair.getPrivate().getAlgorithm())) { + keyPair = pair; + } + } Class AndroidKeyStoreKeyPairGeneratorSpi = XposedHelpers.findClassIfExists("android.security.keystore2.AndroidKeyStoreKeyPairGeneratorSpi", lpparam.classLoader); - XposedHelpers.findAndHookMethod(AndroidKeyStoreKeyPairGeneratorSpi, "generateKeyPair", XC_MethodReplacement.returnConstant(RSA_KEYPAIR)); - try { - KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore"); - XposedHelpers.findAndHookMethod(keyPairGenerator.getClass(), "generateKeyPair", XC_MethodReplacement.returnConstant(RSA_KEYPAIR)); + if (AndroidKeyStoreKeyPairGeneratorSpi == null) { - keyPairGenerator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore"); - XposedHelpers.findAndHookMethod(keyPairGenerator.getClass(), "generateKeyPair", XC_MethodReplacement.returnConstant(RSA_KEYPAIR)); + KeyPairGeneratorSpi keyGenerator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore"); + XposedHelpers.findAndHookMethod(keyGenerator.getClass(), "generateKeyPair", XC_MethodReplacement.returnConstant(keyPair)); - } catch (NoSuchAlgorithmException | NoSuchProviderException e) { + } else { - XposedBridge.log("[BootloaderSpoofer] ERROR: " + e); + XposedHelpers.findAndHookMethod(AndroidKeyStoreKeyPairGeneratorSpi, "generateKeyPair", XC_MethodReplacement.returnConstant(keyPair)); } - Class Builder = XposedHelpers.findClass(KeyGenParameterSpec.Builder.class.getName(), lpparam.classLoader); - XposedHelpers.findAndHookMethod(Builder, "setAttestationChallenge", byte[].class, new XC_MethodHook() { + XposedHelpers.findAndHookMethod(KeyGenParameterSpec.Builder.class, "setAttestationChallenge", byte[].class, new XC_MethodHook() { @Override - protected void afterHookedMethod(XC_MethodHook.MethodHookParam param) { + protected void beforeHookedMethod(MethodHookParam param) { attestationChallengeBytes = (byte[]) param.args[0]; - XposedBridge.log("[BootloaderSpoofer] attestationChallenge: " + Arrays.toString(attestationChallengeBytes)); } }); try { KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore"); - keyStore.load(null); - KeyStoreSpi keyStoreSpi = (KeyStoreSpi) XposedHelpers.getObjectField(keyStore, "keyStoreSpi"); XposedHelpers.findAndHookMethod(keyStoreSpi.getClass(), "engineGetCertificateChain", String.class, new XC_MethodReplacement() { @Override protected Object replaceHookedMethod(MethodHookParam param) { - Deque certificates = new ArrayDeque<>(RSA_CERTS); + LinkedList certificates = new LinkedList<>(Arrays.asList(map.get(keyPair))); try { certificates.addFirst(hackLeafCert()); @@ -282,230 +261,8 @@ protected Object replaceHookedMethod(MethodHookParam param) { return certificates.toArray(new Certificate[0]); } }); - } catch (CertificateException | KeyStoreException | IOException | - NoSuchAlgorithmException e) { - + } catch (KeyStoreException e) { XposedBridge.log("[BootloaderSpoofer] ERROR: " + e); } } - - private static final String KEYBOX = """ - - - 1 - - -----BEGIN EC PRIVATE KEY----- - MHcCAQEEINHUR+pr+/0UCLbjPYQq/2bw6JekJvor38TVlVAUMP5uoAoGCCqGSM49 - AwEHoUQDQgAE8QKCOumQkEdLnqps1h6aYQM/O4VREnhHF0tJ3pcQ0cfQS5WgnhzP - OD5vloDit6xBGoUXs+QqtMEflqYClhCL/Q== - -----END EC PRIVATE KEY----- - 3 - -----BEGIN CERTIFICATE----- - MIICKzCCAbKgAwIBAgIKAndWeGYmQ2cZQTAKBggqhkjOPQQDAjAbMRkwFwYDVQQF - ExA1YjAzNTljY2E4ODc5Y2I1MB4XDTE2MDUyNjE2NTczNVoXDTI2MDUyNDE2NTcz - NVowGzEZMBcGA1UEBRMQMzQ0NjZhZWI2Nzc3NmMyNzBZMBMGByqGSM49AgEGCCqG - SM49AwEHA0IABPECgjrpkJBHS56qbNYemmEDPzuFURJ4RxdLSd6XENHH0EuVoJ4c - zzg+b5aA4resQRqFF7PkKrTBH5amApYQi/2jgd0wgdowHQYDVR0OBBYEFN3jZFzm - lLhaMqADvRaisWt1mMOFMB8GA1UdIwQYMBaAFAbd7gqSHZtx4caJQUTvOTlwJgA1 - MAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgeAMCQGA1UdHgQdMBugGTAXghVp - bnZhbGlkO2VtYWlsOmludmFsaWQwVAYDVR0fBE0wSzBJoEegRYZDaHR0cHM6Ly9h - bmRyb2lkLmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC8wMjc3NTY3ODY2 - MjY0MzY3MTk0MTAKBggqhkjOPQQDAgNnADBkAjAThg70bAjRwWEffDdAV7aarwB6 - mw4ccMG/0apN4/Bb6Jz4wyXUj4DxhtcTOIvVfrICMEiDdyXEsZZl8yrOGs6Z6XWJ - Fd3EdZ5vLcC1+ZdSNNveJfW1u0+iP1WaDktKfTjvNw== - -----END CERTIFICATE----- - - -----BEGIN CERTIFICATE----- - MIIDwzCCAaugAwIBAgIKA4gmZ2BliZaFczANBgkqhkiG9w0BAQsFADAbMRkwFwYD - VQQFExBmOTIwMDllODUzYjZiMDQ1MB4XDTE2MDUyNjE2NDEyOVoXDTI2MDUyNDE2 - NDEyOVowGzEZMBcGA1UEBRMQNWIwMzU5Y2NhODg3OWNiNTB2MBAGByqGSM49AgEG - BSuBBAAiA2IABHf4FUKTZivDuwdyVbXyPF12IRuDzZKq61MbqooE3/gx9gIS9pFS - 4NZgGTnjSMm6ltYrCv3sDzuPQls+V+BLPQgNfRHavmP9eulc1uR3GNgCnKqxB2o0 - QcTQGPAxJA81c6OBtjCBszAdBgNVHQ4EFgQUBt3uCpIdm3HhxolBRO85OXAmADUw - HwYDVR0jBBgwFoAUNmHhAHyIBQlRi0RsR/8aTMnqTxIwDwYDVR0TAQH/BAUwAwEB - /zAOBgNVHQ8BAf8EBAMCAYYwUAYDVR0fBEkwRzBFoEOgQYY/aHR0cHM6Ly9hbmRy - b2lkLmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC9FOEZBMTk2MzE0RDJG - QTE4MA0GCSqGSIb3DQEBCwUAA4ICAQAsPFNbAeVGRXKg0H1Ixy31n+vc1GAtLTtd - ruQGZ3rk6Dq3G5OiNfwLI4vRowDERgTr5RoVRMLs9HzTTCvvdEBhcILKOnaPAd6J - g4HvBi8hsfbXEvRi2kmIfiYAabC71ErJLFEMprTJMSDEOe3lXCJG409z99ofsf/s - 1M1i77NFVCwstAvRLMjc9TjxRXrGrGD0rMdG2RkionXa3H+4cYqSUf7JCIW6dMB2 - p+4R3n463DqxxSJNGbchGGUbL6b0qIWdaVcwG2ro+WyItfyw5C4h9XSosauyC9aj - jZLt8RAK2ouZHN/kyIXcD1U7IFbSy0SZfaRDLNCzse4iL6IOnuyITEFLnvLfcDSw - NX1/ptBRAeeme7G1nwpeohJjiddmf20e421+n3tWUyUhLk9s83MJQQp+mhfApA1Q - vz+a7M3OqPvHhBoeu6C4NOlYkb8mrjtuZ/RU5WIRXfyXZqA05Qnu8usuxxNFozU5 - hWbXIZQx7at2x/7t8/kgHSJhKs4hWIdbVgIDyWIhgoDD+gqTIRlzTwrS876dgy0M - TZm1riMEBB5jvAhaeciDBf8u6AFWnMsS0UVtOinr5lTRkHSwie2n90kazqpkeMUd - nbBSG7HSMhyg5lvem9G82NakH4S1EPgRBLN1eF8Q51ZmzeNl3DnIGGjNI+LAXw10 - KVuEkzgd8A== - -----END CERTIFICATE----- - - -----BEGIN CERTIFICATE----- - MIIFYDCCA0igAwIBAgIJAOj6GWMU0voYMA0GCSqGSIb3DQEBCwUAMBsxGTAXBgNV - BAUTEGY5MjAwOWU4NTNiNmIwNDUwHhcNMTYwNTI2MTYyODUyWhcNMjYwNTI0MTYy - ODUyWjAbMRkwFwYDVQQFExBmOTIwMDllODUzYjZiMDQ1MIICIjANBgkqhkiG9w0B - AQEFAAOCAg8AMIICCgKCAgEAr7bHgiuxpwHsK7Qui8xUFmOr75gvMsd/dTEDDJdS - Sxtf6An7xyqpRR90PL2abxM1dEqlXnf2tqw1Ne4Xwl5jlRfdnJLmN0pTy/4lj4/7 - tv0Sk3iiKkypnEUtR6WfMgH0QZfKHM1+di+y9TFRtv6y//0rb+T+W8a9nsNL/ggj - nar86461qO0rOs2cXjp3kOG1FEJ5MVmFmBGtnrKpa73XpXyTqRxB/M0n1n/W9nGq - C4FSYa04T6N5RIZGBN2z2MT5IKGbFlbC8UrW0DxW7AYImQQcHtGl/m00QLVWutHQ - oVJYnFPlXTcHYvASLu+RhhsbDmxMgJJ0mcDpvsC4PjvB+TxywElgS70vE0XmLD+O - JtvsBslHZvPBKCOdT0MS+tgSOIfga+z1Z1g7+DVagf7quvmag8jfPioyKvxnK/Eg - sTUVi2ghzq8wm27ud/mIM7AY2qEORR8Go3TVB4HzWQgpZrt3i5MIlCaY504LzSRi - igHCzAPlHws+W0rB5N+er5/2pJKnfBSDiCiFAVtCLOZ7gLiMm0jhO2B6tUXHI/+M - RPjy02i59lINMRRev56GKtcd9qO/0kUJWdZTdA2XoS82ixPvZtXQpUpuL12ab+9E - aDK8Z4RHJYYfCT3Q5vNAXaiWQ+8PTWm2QgBR/bkwSWc+NpUFgNPN9PvQi8WEg5Um - AGMCAwEAAaOBpjCBozAdBgNVHQ4EFgQUNmHhAHyIBQlRi0RsR/8aTMnqTxIwHwYD - VR0jBBgwFoAUNmHhAHyIBQlRi0RsR/8aTMnqTxIwDwYDVR0TAQH/BAUwAwEB/zAO - BgNVHQ8BAf8EBAMCAYYwQAYDVR0fBDkwNzA1oDOgMYYvaHR0cHM6Ly9hbmRyb2lk - Lmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC8wDQYJKoZIhvcNAQELBQAD - ggIBACDIw41L3KlXG0aMiS//cqrG+EShHUGo8HNsw30W1kJtjn6UBwRM6jnmiwfB - Pb8VA91chb2vssAtX2zbTvqBJ9+LBPGCdw/E53Rbf86qhxKaiAHOjpvAy5Y3m00m - qC0w/Zwvju1twb4vhLaJ5NkUJYsUS7rmJKHHBnETLi8GFqiEsqTWpG/6ibYCv7rY - DBJDcR9W62BW9jfIoBQcxUCUJouMPH25lLNcDc1ssqvC2v7iUgI9LeoM1sNovqPm - QUiG9rHli1vXxzCyaMTjwftkJLkf6724DFhuKug2jITV0QkXvaJWF4nUaHOTNA4u - JU9WDvZLI1j83A+/xnAJUucIv/zGJ1AMH2boHqF8CY16LpsYgBt6tKxxWH00XcyD - CdW2KlBCeqbQPcsFmWyWugxdcekhYsAWyoSf818NUsZdBWBaR/OukXrNLfkQ79Iy - ZohZbvabO/X+MVT3rriAoKc8oE2Uws6DF+60PV7/WIPjNvXySdqspImSN78mflxD - qwLqRBYkA3I75qppLGG9rp7UCdRjxMl8ZDBld+7yvHVgt1cVzJx9xnyGCC23Uaic - MDSXYrB4I4WHXPGjxhZuCuPBLTdOLU8YRvMYdEvYebWHMpvwGCF6bAx3JBpIeOQ1 - wDB5y0USicV3YgYGmi+NZfhA4URSh77Yd6uuJOJENRaNVTzk - -----END CERTIFICATE----- - - -----BEGIN RSA PRIVATE KEY----- - MIIG4wIBAAKCAYEAvi/S/O6oSA3ityc+Qo2w+GvpaRFRlN8rjlo48Zon5DZbI9Ep - fYx2NrfpCLIiD22I8FuiTzBFhJ5jTa+FJ7DAP9sFRVW+5KzzNg1j2Nlo4yDj22iN - FUxW0TwmE7kbWVJYy5dbMgonlCjXHUEbKN9cNSe0hKRQfG9Q+Ccy/Pd2B/KBXTrR - xTK1OceuyPQUNElubj0W9+kQGtSPyR40XjXcYjjsQn1CTU1yGoBP1Qdi8M+3r40X - 41CUbHT0pFwiYXrwOAdle8HTVp0ZjVslGiPold5ZRrI0n0PYa7wiT5uH5eIaOMki - cjfg4FWSo/cX7Qb/PEI54EKDLxCTYDZDSUwaZ6Ohe3oPgJzhGdR3J4LIb7pxNCSN - 88cS5YyhrwxAun+M7Z9jqpC9XyUikCTqqNplvtF3m105kPEIJqCtZYNo0F3R7v2z - MdwrwYMU5Ns2WXrqLya7M9TKxHSjrMDOFVdb6FEDu47JVXp9OaPUsHrDpTHOvpeL - gy9rMTdBBzGvSqJjAgMBAAECggGAGAgA9/bMCra+c/ggdNZkiy9PgfgvP8lnPoiF - 83lQGxUHNSJjxLpv4YAhkPi5NwvXJs/dVXY7AoPk9lb8U0SRNkBdjSJFia2U2bqd - aDQofbKVOA8g7JUFz1BzW0CjhQjTsX4BhvQjhiQW8lpcrTBz/T90HuKITQDf0Uta - tP4ryttIn1gkU2+R2KgznK7CssyoiINtmIu5fjpnpLkNUu4pV7vrlocvToc/qLuX - 2sohJV6JzkPcxdtTtdSdaPs/WOPoqK8uWXItyXsGY0sIZ/rsxExQpB1gkPaJATAw - HAZmC9qZAs/o4RuSbY7BWqcMIqYCHyRmCwSVK4ADHGwAPnvmQwrYaw8oYRDMSHwP - dy0CtYmWdZsuw9aryrqBKj9xdmNhodzPAjU+Ia/iLHdnbQrSYf2mWDJrax8+EwyW - Q4ORsRztGAeFh2E3Bw22kGfZ9HPBZnl5n8fKtlM7jJgRhsaB/RhfHD2OSRAHSy+J - 17vHBa9Iikw/5GtWxqAy06JMbobBAoHBAO4YqhZZ0FdJxKhz6fGtMJkZQoALJFG0 - AXgG41mczTIuK+HUvUKMd8eB/HNW/YXFDJFlBzcLYormBVytem63vK83MBNCnwXL - EoqfCS4Zvi3c47TX6zQ9w0gffkK1tyx571j0HICm2uJ1Eo/AFXQMvBUNPDBOMDiq - IA2SI+RrHG44lyLxVm9G51D3r9Mv8uNeZ0AP3RKNyAM1DywvUdQ/W8Iqh6daffVQ - /XIhHH4++1IwOposkdiULEprUJXP/jlWYQKBwQDMfOe1JgC4YiTAQcmz6D5FgiF9 - apsBE8BU1ZKreeuB8S0VK/0JMsxD+hvB4OfePd/WCPdykhodpzZrrjtgL5/wtwZK - 5GPz37Ubu9iHKvfQxbfQDuODPYVcvqmJURMQ6s/2l2d37uHe9pzlumAmyqajrOmX - 3FF7UCy/yYbvbsJE0dkMRNNBzXzRl45OCA5+/iCer3zdv3+0yqqsSu+By8YK70vt - O1uGTOptL0gIBDzDdl2HqKShwgGJvvD5PtGIZ0MCgcAnjXNb6SmiBoAj17WqTzH+ - jOKuMKuk4vlHfiVwcorn5iGmD1gtYPZY7zAH3RCak0RmNtk+/KYvGs0TO0JWeDFh - DhLvcCbIqJZ47rhwrxgXuFUfaqsI76WsKocn/9XhDpSDO3IssQs1iWs+9BLcR21L - Nfqkr6h1EVXnyzopLN35NW9t/5dzPt0YZz0PIS0BNmKCkuAPv/vVBJBzr5yxXKEa - nUQRugeoo/6mYffAxSes3JQvnm3QA7Vj23X0nSvHTKECgcEAh8c4I3REbinctTv5 - rle7YXPywNAUdDalMq9NYEboNbPqd3Bp572vHEPqQmYQD+WNxxTVGWIhrSbmX8Gk - 800sKi2dJAVayQf1vaCROc8yFZHzZ1c7gl1LPDXtZJxMyKLhy57kuSIJIH8n1vJV - /ev5khyyTn+gKv0leYNa8YjdvcyJDjh0/fBvvMuhVfbLiU88YaGsi6EoLueTRCvN - tKWVrpUOGUucjiRsVGtcrNYDctYZbIZyKmYjl08NurIXdzb5AoHAJ/CeIPJ891ht - 2kTZjdWoGZEAxLp2sRmU7YV1z6s4ybIQESykCSZbBWMhO7Fo6w6kF9MyFXeCUGbq - o2EziCbW6A3W41GAAXLIMLIoLI77xShluGlEizdYic0vz5iDQEHhA9NqvUCQ5yYj - bf/jhC2NoX2bt4QQfAVwvhUpF8lpsQYv3J7eSFgh9V6ADvIZb+c1xuaUWeKf87Q9 - k3O1AUJryT0QlFc+grIxRv8xUa6nG5B3KaHrRpjhXz+KIBeoMccU - -----END RSA PRIVATE KEY----- - 3 - -----BEGIN CERTIFICATE----- - MIIFGDCCAwCgAwIBAgIKEEeAUVAYhhGBQDANBgkqhkiG9w0BAQsFADAbMRkwFwYD - VQQFExA1YjAzNTljY2E4ODc5Y2I1MB4XDTE2MDUyNjE2NTcyNFoXDTI2MDUyNDE2 - NTcyNFowGzEZMBcGA1UEBRMQMzQ0NjZhZWI2Nzc3NmMyNzCCAaIwDQYJKoZIhvcN - AQEBBQADggGPADCCAYoCggGBAL4v0vzuqEgN4rcnPkKNsPhr6WkRUZTfK45aOPGa - J+Q2WyPRKX2Mdja36QiyIg9tiPBbok8wRYSeY02vhSewwD/bBUVVvuSs8zYNY9jZ - aOMg49tojRVMVtE8JhO5G1lSWMuXWzIKJ5Qo1x1BGyjfXDUntISkUHxvUPgnMvz3 - dgfygV060cUytTnHrsj0FDRJbm49FvfpEBrUj8keNF413GI47EJ9Qk1NchqAT9UH - YvDPt6+NF+NQlGx09KRcImF68DgHZXvB01adGY1bJRoj6JXeWUayNJ9D2Gu8Ik+b - h+XiGjjJInI34OBVkqP3F+0G/zxCOeBCgy8Qk2A2Q0lMGmejoXt6D4Cc4RnUdyeC - yG+6cTQkjfPHEuWMoa8MQLp/jO2fY6qQvV8lIpAk6qjaZb7Rd5tdOZDxCCagrWWD - aNBd0e79szHcK8GDFOTbNll66i8muzPUysR0o6zAzhVXW+hRA7uOyVV6fTmj1LB6 - w6Uxzr6Xi4MvazE3QQcxr0qiYwIDAQABo4HdMIHaMB0GA1UdDgQWBBQB+NeLZ3O6 - x5CwQduHzprmNQN8JTAfBgNVHSMEGDAWgBRkdqBZ1YRFXa5o2jjSEQcsqmE9ojAM - BgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAkBgNVHR4EHTAboBkwF4IVaW52 - YWxpZDtlbWFpbDppbnZhbGlkMFQGA1UdHwRNMEswSaBHoEWGQ2h0dHBzOi8vYW5k - cm9pZC5nb29nbGVhcGlzLmNvbS9hdHRlc3RhdGlvbi9jcmwvMTA0NzgwNTE1MDE4 - ODYxMTgxNDAwDQYJKoZIhvcNAQELBQADggIBAEK/q4OEziSIP+auL8oYFsckpZQN - 8YcGPN74LAKNBGDh0e5MV1CjYevM+FG79euAQfkKZJ0eRVH/LYHzrr/cLwv+HE8q - tsj57PObOepIup7MTyike1qjlgKu3NEjcNYa6T4kR8nZaycGhpL/kQpbIXCBOc5T - 6DTT/mwYEpSLu+P5KsaHiUng3DVJZPX4F3ZNN+7WuPoLZriZX9cCk6uOTVxQeSm4 - rCfD6BpL0zJHtqjQbetijREg+QjqFVNwkwBS1W3J8kLk02AoNjtem1yAy6emxlQx - TeCfm+cS0whsWo66mwwIxxp72VisgpzlrhfZiAwAxMhAT40ygfeTWAYpClYRSr/1 - 1/X5k6HYB14BnNSfhEFkqhC9XOdtZN9lcFyDgoIDm9sRtLiBq7yGhxeX8M+9bavg - aQMyPFpMnFXrKNdr7tBVVQ7sG9cavZRGGIIJYS44c/GSZiYfBrS45raHq6l6i0aj - HOfvSOfFSRmbL4s78DNIdW6ZlzwQRtGjMcGSiPyVCOqu196x2Op08P4LfWXdSecU - 285/+zj1oa4inyOA/TKdEqg1d7m1cEoOElw9i0JivqAscpQUXlSqsGORKrmoVKl4 - gUuJeCvo1la/tluXSOPJeAllwHtgNj9flzXMHTKcsrZ+tOiDnzwl3qIwr11o/iHA - 7qaZlBkmipuwCn9r - -----END CERTIFICATE----- - - -----BEGIN CERTIFICATE----- - MIIFcTCCA1mgAwIBAgIKA4gmZ2BliZaFcjANBgkqhkiG9w0BAQsFADAbMRkwFwYD - VQQFExBmOTIwMDllODUzYjZiMDQ1MB4XDTE2MDUyNjE2NDExMVoXDTI2MDUyNDE2 - NDExMVowGzEZMBcGA1UEBRMQNWIwMzU5Y2NhODg3OWNiNTCCAiIwDQYJKoZIhvcN - AQEBBQADggIPADCCAgoCggIBAKQpnVM0Ms0TsKD99lxs+uvM6ZFYDuL5cOIOw/MC - 2vFRXhoUwJDGlNEgFj8RIHiz72nAdMh9qCnZxGy9YxePWHc3JGoTCjbRR/ztoUWm - 5ajyJCTEGdbHm8d6qhGyFV2GbDXNri1r55Bu/HJFavMeTanwibCXy3pee2NLzHUr - aryUKA5gv/qji9LzM+Bl+MBNmVcrF+Uyo1hSdp3qK5CfWnN5jUrLafOu7F95d7On - OJ9DdXNYqJj94TNp3sBfbCYmbzCVBV4YBgVuAGD6jWEkGa/a6aZudqjEghHeYlQE - hUYuvbkVi4ce7OmJv0K9icX5Nn20pTpCe1tWT6y+Yrl2JEe7NJ5Q29f9nU6jkzm7 - /2ZxnpXA1+RyPr77/MqX1KigblZvJkFHXWaSNiLEWAVZi/dSNku/t/RGz9IZX6rJ - Tz+Ajd28kWsO+HhzNZAkXwCTb4ltBenykeiiS7Obll3dfuubOV3G/egJzQG0GR9x - Y8s9GzfDe8OHXsKeBmXCGK8h0g7sjbHY86wrlmoUw9Z3ozhbQKGCV/eV6YQD/NwT - yGFom5e2sBMy0fTloh+xVCQ4HxSaGSPDE9dA8rjf/GRLqL41O//o63HJ8Qm5ly6i - dnB8pN27V0ACAewlJnOLhFugGlwLFTmg6/P2dlvaViZ67c0Evf3bv5qqMJK5l4v1 - aDmdAgMBAAGjgbYwgbMwHQYDVR0OBBYEFGR2oFnVhEVdrmjaONIRByyqYT2iMB8G - A1UdIwQYMBaAFDZh4QB8iAUJUYtEbEf/GkzJ6k8SMA8GA1UdEwEB/wQFMAMBAf8w - DgYDVR0PAQH/BAQDAgGGMFAGA1UdHwRJMEcwRaBDoEGGP2h0dHBzOi8vYW5kcm9p - ZC5nb29nbGVhcGlzLmNvbS9hdHRlc3RhdGlvbi9jcmwvRThGQTE5NjMxNEQyRkEx - ODANBgkqhkiG9w0BAQsFAAOCAgEAXivYRipVRq8tdLaEbp7fr0Du5wmh8nY+bI0K - Ae9ltKLwpXml2YcpIe/qw+yV7qg0IiQAkmMQJQp4drAEkDxw8WNINFXvnlDB32ru - ZP9HrFY6lxLSGYGH/qnOJJnTV/nFkZ+uEtnn7j6U/rrH4kh0mhyu58sN49FkHMfA - 4E8gGuDMRuVbFOWA5Ghqn65KFkU61u/X5d1gFFZiQApL6NMw8rCKCUbGbfOyH91I - 2OHWRnNXFVS0p5siXXPZzmaJ4PJuFgtzqCW6rvRS2FfRg3niiUR9vut38Oavn0wr - /JiZLUsGyzdpJKzLJNfTAnGN5QLduYNuSYNZoBawlC5PZSwFqsf/VKNVYtwjog/v - 5o/zoZOfD2f9oWyJ7wxNPc9/cAVIgA+gW6/jZAXW9BoYZZ7SJ0DmsZP1L7hNIUZS - 8cluYuZ/3TdwqXgCV6CuZA6MLSWjCKJ5OxS2JAUf3VInUmszTwI9ULugMCPb9gYj - lLp04t2HbMN+ky9Ath6/yH4XkGF6AtTLpWHnwW6L2kzZyJdY5cm5n0hfrdtejUyG - DJnJKQSVSzldalAu8OVoCd5QcHpEkoR40zMH5zGXm6JgpRBuCi/JZ8WJNkqBAqWv - +cHFXCwulE0E3nnevqMDsF2BVmGZz80BF7EXDwHuqMVcAbd22el3L9UP7oiOn2jJ - yhC5FAE= - -----END CERTIFICATE----- - - -----BEGIN CERTIFICATE----- - MIIFYDCCA0igAwIBAgIJAOj6GWMU0voYMA0GCSqGSIb3DQEBCwUAMBsxGTAXBgNV - BAUTEGY5MjAwOWU4NTNiNmIwNDUwHhcNMTYwNTI2MTYyODUyWhcNMjYwNTI0MTYy - ODUyWjAbMRkwFwYDVQQFExBmOTIwMDllODUzYjZiMDQ1MIICIjANBgkqhkiG9w0B - AQEFAAOCAg8AMIICCgKCAgEAr7bHgiuxpwHsK7Qui8xUFmOr75gvMsd/dTEDDJdS - Sxtf6An7xyqpRR90PL2abxM1dEqlXnf2tqw1Ne4Xwl5jlRfdnJLmN0pTy/4lj4/7 - tv0Sk3iiKkypnEUtR6WfMgH0QZfKHM1+di+y9TFRtv6y//0rb+T+W8a9nsNL/ggj - nar86461qO0rOs2cXjp3kOG1FEJ5MVmFmBGtnrKpa73XpXyTqRxB/M0n1n/W9nGq - C4FSYa04T6N5RIZGBN2z2MT5IKGbFlbC8UrW0DxW7AYImQQcHtGl/m00QLVWutHQ - oVJYnFPlXTcHYvASLu+RhhsbDmxMgJJ0mcDpvsC4PjvB+TxywElgS70vE0XmLD+O - JtvsBslHZvPBKCOdT0MS+tgSOIfga+z1Z1g7+DVagf7quvmag8jfPioyKvxnK/Eg - sTUVi2ghzq8wm27ud/mIM7AY2qEORR8Go3TVB4HzWQgpZrt3i5MIlCaY504LzSRi - igHCzAPlHws+W0rB5N+er5/2pJKnfBSDiCiFAVtCLOZ7gLiMm0jhO2B6tUXHI/+M - RPjy02i59lINMRRev56GKtcd9qO/0kUJWdZTdA2XoS82ixPvZtXQpUpuL12ab+9E - aDK8Z4RHJYYfCT3Q5vNAXaiWQ+8PTWm2QgBR/bkwSWc+NpUFgNPN9PvQi8WEg5Um - AGMCAwEAAaOBpjCBozAdBgNVHQ4EFgQUNmHhAHyIBQlRi0RsR/8aTMnqTxIwHwYD - VR0jBBgwFoAUNmHhAHyIBQlRi0RsR/8aTMnqTxIwDwYDVR0TAQH/BAUwAwEB/zAO - BgNVHQ8BAf8EBAMCAYYwQAYDVR0fBDkwNzA1oDOgMYYvaHR0cHM6Ly9hbmRyb2lk - Lmdvb2dsZWFwaXMuY29tL2F0dGVzdGF0aW9uL2NybC8wDQYJKoZIhvcNAQELBQAD - ggIBACDIw41L3KlXG0aMiS//cqrG+EShHUGo8HNsw30W1kJtjn6UBwRM6jnmiwfB - Pb8VA91chb2vssAtX2zbTvqBJ9+LBPGCdw/E53Rbf86qhxKaiAHOjpvAy5Y3m00m - qC0w/Zwvju1twb4vhLaJ5NkUJYsUS7rmJKHHBnETLi8GFqiEsqTWpG/6ibYCv7rY - DBJDcR9W62BW9jfIoBQcxUCUJouMPH25lLNcDc1ssqvC2v7iUgI9LeoM1sNovqPm - QUiG9rHli1vXxzCyaMTjwftkJLkf6724DFhuKug2jITV0QkXvaJWF4nUaHOTNA4u - JU9WDvZLI1j83A+/xnAJUucIv/zGJ1AMH2boHqF8CY16LpsYgBt6tKxxWH00XcyD - CdW2KlBCeqbQPcsFmWyWugxdcekhYsAWyoSf818NUsZdBWBaR/OukXrNLfkQ79Iy - ZohZbvabO/X+MVT3rriAoKc8oE2Uws6DF+60PV7/WIPjNvXySdqspImSN78mflxD - qwLqRBYkA3I75qppLGG9rp7UCdRjxMl8ZDBld+7yvHVgt1cVzJx9xnyGCC23Uaic - MDSXYrB4I4WHXPGjxhZuCuPBLTdOLU8YRvMYdEvYebWHMpvwGCF6bAx3JBpIeOQ1 - wDB5y0USicV3YgYGmi+NZfhA4URSh77Yd6uuJOJENRaNVTzk - -----END CERTIFICATE----- - - """; }