Keystore: innebörd, vilka format som finns och hur det fungerar

Vad är Keystore

Keystore (KeyStore) — är en standardmekanism i Java Cryptography Architecture (JCA) för lagring av kryptografiska nycklar, certifikat och betrodda poster. I Android-utveckling används Keystore för att lagra den privata nyckeln som appen signeras med före publicering. Signaturen garanterar att appen verkligen har släppts av den angivna utvecklaren och att dess kod inte har ändrats efter publicering. Varje appuppdatering måste signeras med samma nyckel, annars kommer Google Play att avvisa APK:n eller App Bundle:n.

Keystore kan innehålla flera poster (alias), där varje post representerar ett nyckelpar (privat och offentlig) med ett certifikat. Alias — det unika namnet på posten under vilken appen får åtkomst till nyckeln vid signering. I ett typiskt Android-projekt innehåller Keystore en post för signering av releaseversionen och kan innehålla ytterligare poster för signering av debug-byggen. Google Play Console visar SHA-1 och SHA-256 fingeravtryck för certifikatet för varje uppladdad app.

Android Studio har inbyggt stöd för Keystore via menyn Build → Generate Signed Bundle / APK. Signeringsguiden i Android Studio gör det möjligt att skapa en ny Keystore eller välja en befintlig, ange alias, Keystore- och nyckellösenord samt certifieringsdata (organisationsnamn, stad, land). Dessa data bäddas in i certifikatet och syns för användare vid verifiering av APK-signaturen. Google Play kräver att certifikatets giltighet är minst 25 år — Android kontrollerar utgångsdatumet vid installation av appen.

Varför Keystore är viktigt för Android

Uppdatering av appen i Google Play är endast möjlig med samma nyckel som den första versionen signerades med. Om Keystore förloras är det omöjligt att publicera en uppdatering — appen måste släppas på nytt under ett nytt paketnamn (package name). Enligt Google Play Console Help (2026) kan appens signeringsnyckel endast återställas via Google Play App Signing — en tjänst som lagrar nyckeln på Googles sida. Om utvecklaren har använt detta alternativ är förlusten av den lokala Keystore inte kritisk.

Hur Keystore fungerar

Processen för att signera en Android-app omfattar att skapa en sammanfattning (hash) av APK-innehållet och kryptera den med den privata nyckeln från Keystore. Android SDK Build Tools innehåller verktyget apksigner som utför signering i formatet APK Signature Scheme v2 (eller v3 för Android 9+). Vid installation av appen verifierar Android signaturen: den dekrypterar signaturen med certifikatets offentliga nyckel, jämför APK:ns hash med originalet — om hasharna inte matchar avvisas installationen.

Android stöder flera signeringsscheman: v1 (JAR signing), v2 (APK Signature Scheme), v3 (APK Signature Scheme med stöd för nyckelrotation) och v4 (inkrementella installationer Android 11+). Google Play kräver v2 eller v3 för nya appar. apksigner lägger automatiskt till alla nödvändiga scheman vid signering, om nyckeln stöder motsvarande algoritmer. Android 11+ stöder ADB-installation med v4-signatur, vilket snabbar upp inkrementell laddning av stora APK-filer till enheten.

Algoritmer: Android rekommenderar användning av RSA-2048 eller ECDSA P-256 för signeringsnyckeln. Certifikatet bör vara X.509 v3. Android kontrollerar om certifikatet är giltigt vid installationstillfället — om det har löpt ut blockeras installationen. Det är därför Google rekommenderar att certifikatets giltighetsperiod sätts till minst 25 år. Google Play App Signing använder två nycklar: appens signeringsnyckel (app signing key) och uppladdningsnyckel (upload key) — uppladdningsnyckeln används av utvecklaren för att ladda upp APK:n till Console, och Google signerar appen för användare med huvudnyckeln.

Keystore-format: JKS och PKCS12

Java stöder två huvudsakliga Keystore-format: JKS (Java KeyStore) — Oracles proprietära format, som funnits sedan JDK 1.2, och PKCS12 — det standardiserade formatet Public-Key Cryptography Standards #12 från RSA Laboratories. JKS använder sitt eget data lagringsformat och stöds endast i Java-ekosystemet. PKCS12 är en öppen standard som stöds av Java, .NET, OpenSSL, Python (cryptography) och de flesta andra kryptografiska bibliotek.

Google Play rekommenderar PKCS12 som föredraget format för nya Keystore som skapas efter 2021. JDK 9 och nyare skapar som standard Keystore i PKCS12-format (tidigare var JKS standard). Den största fördelen med PKCS12 är kompatibilitet: .p12-filen kan öppnas i vilken miljö som helst som inte är bunden till Java. OpenSSL kan extrahera certifikat från PKCS12 och konvertera dem till PEM-format. JKS-filer kräver JDK-verktyg för att läsas och kan inte bearbetas av OpenSSL.

Konvertering mellan format görs med verktyget keytool från JDK. Vid migrering från JKS till PKCS12 måste man säkerställa att alla alias och lösenord har överförts korrekt. Kommandot keytool -importkeystore gör det möjligt att importera innehållet från en Keystore till en annan oavsett format. Efter konvertering är det bättre att ta bort den gamla JKS-filen för att undvika förvirring med nyckelversioner. Android Studio stöder båda formaten vid generering av ett signerat bygge.

Skapa Keystore via keytool

Verktyget keytool ingår i JDK (Java Development Kit) och tillhandahåller en komplett uppsättning kommandon för att skapa, visa och hantera Keystore. För att skapa en ny Keystore med ett nyckelpar används kommandot keytool -genkeypair med angivelse av PKCS12-format, RSA-algoritm, nyckelstorlek och certifikatets giltighetsperiod. Google Play kräver certifikatets giltighet på minst 25 år (9125 dagar) — detta värde rekommenderas att anges i parametern -validity.

Skapa en ny Keystore

Exempel på generering av en Keystore i PKCS12-format för ett Android-projekt. Parametern -dname innehåller certifikatets X.500 Distinguished Name. Parametern -ext aktiverar Subject Alternative Name om det behövs — för Android räcker Basic Constraints:

# Skapa PKCS12 Keystore för Android
keytool -genkeypair -alias "upload_key" \
  -keyalg RSA -keysize 2048 -validity 9125 \
  -keystore "release-keystore.p12" \
  -storetype PKCS12 \
  -dname "CN=Developer,O=Company,C=RU"

Keytool kommer att fråga efter Keystore-lösenordet och nyckellösenordet (kan vara samma). Parametern -storetype PKCS12 skapar filen i modernt format. -keysize 2048 uppfyller Googles krav på minsta RSA-nyckelstorlek. -validity 9125 (25 år) säkerställer kompatibilitet under hela appens förväntade livscykel. Efter att Keystore har skapats rekommenderas det att kontrollera dess innehåll med kommandot keytool -list -v -keystore release-keystore.p12.

Visa innehållet i Keystore

För att kontrollera Keystore-poster används kommandot med flaggan -list. Utdata innehåller alias, datum för skapande och utgång, posttyp och SHA-256 fingeravtryck. Android Studio visar samma information i dialogrutan Generate Signed Bundle / APK vid val av en befintlig Keystore:

# Visa Keystore-poster
keytool -list -v -keystore "release-keystore.p12" \
  -storetype PKCS12

Använda Keystore i CI/CD

I CI/CD-pipelinen måste Keystore lagras säkert och överföras till byggagenten utan risk för kompromettering. GitHub Actions tillhandahåller Secrets för lagring av binära filer i base64-format. Keystore kodas med kommandot base64, den resulterande strängen lagras i repositoryts hemligheter och i byggfasen avkodas den tillbaka till en fil. GitLab CI använder en liknande mekanism via Variables med typen File.

Ett exempel på konfiguration av CI-bygge med Keystore i GitHub Actions inkluderar avkodning av Keystore från hemligheten, konfiguration av Gradle-egenskaper och utförande av det signerade bygget. Gradle Android-plugin läser sökvägen till Keystore och lösenord från filen keystore.properties (exkluderad från .gitignore för lokal utveckling) eller från CI-systemets miljövariabler:

// build.gradle (app) — signeringskonfiguration
@Override
android {
    signingConfigs {
        release {
            storeFile file("release-keystore.p12")
            storePassword System.getenv("STORE_PASSWORD")
            keyAlias System.getenv("KEY_ALIAS")
            keyPassword System.getenv("KEY_PASSWORD")
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Gradle läser miljövariabler som ställts in av CI-systemet. Keystore-filen bör finnas i rotkatalogen för appmodulen, som anges i storeFile. För säkerhets skull, förvara aldrig lösenord i repositoryt — använd CI-systemets Secrets. Fastlane för Android tillhandahåller plugin-programmet supply som fungerar med Google Play Console, men signering av APK kräver fortfarande en lokal Keystore på agenten.

Ett alternativ är Google Play App Signing. När detta alternativ används laddar utvecklaren endast upp uppladdningsnyckeln (upload key) till Google Play, och Google signerar den slutliga APK:n med sin egen nyckel. I detta fall används Keystore endast för att skapa uppladdningsnyckeln, och dess förlust blockerar inte uppdateringar — en ny upload key kan genereras och registreras i Console. Google Play App Signing är obligatoriskt för nya appar från augusti 2021.

Säkerhet och säkerhetskopiering av Keystore

Förlust av Keystore är ett av de mest kritiska problemen inom Android-utveckling. Utan säkerhetskopia av Keystore kan ingen uppdatering av den befintliga appen släppas — Google Play avvisar APK signerad med en annan nyckel. Det rekommenderas att lagra minst två säkerhetskopior av Keystore i olika fysiska eller molnlagringar: till exempel en krypterad fil i teamets molnlagring och ett fysiskt medium i organisationens kassaskåp. Keystore- och nyckellösenord förvaras separat från filen, till exempel i en lösenordshanterare med åtkomstkontroll.

Android Studio när en ny Keystore skapas i dialogrutan Generate Signed Bundle / APK erbjuder sig att komma ihåg sökvägar för framtida byggen. Själva utvecklingsmiljön skapar dock ingen säkerhetskopia — detta är utvecklarens ansvar. För teamutveckling rekommenderas att använda Google Play App Signing med överföring av upload key via en säker kanal till alla teammedlemmar. Gradle gör det möjligt att signera debug-byggen med automatiskt genererad debug.keystore, som inte kräver säkerhetskopiering — den är samma för alla installationer av Android Studio.

Säkerhet för Keystore vid överföring: .p12- eller .jks-filen får endast överföras via krypterade kanaler (SFTP, HTTPS, krypterade e-postbilagor). Inkludera aldrig Keystore i källkodsrepositoryt — inte ens ett privat. GitGuardian eller GitHub secret scanning upptäcker automatiskt publicering av inloggningsuppgifter, men lagring av Keystore i repositoryt är fortfarande ett säkerhetsbrott. För CI/CD, använd plattformens hemlighetsmekanism (GitHub Actions Secrets, GitLab CI Variables, Jenkins Credentials) med kryptering på infrastrukturnivå.