Signez l'APK sans mettre les informations du keystore dans build.gradle

J'essaie de configurer le processus de signature afin que le mot de passe du fichier de clés et le mot de passe clé ne soient pas stockés dans le build.gradlefichier du projet .

Actuellement, j'ai ce qui suit dans le build.gradle:

android {
    ...
    signingConfigs {
        release {
            storeFile file("my.keystore")
            storePassword "store_password"
            keyAlias "my_key_alias"
            keyPassword "key_password"
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release            
        }
    }
}

Cela fonctionne parfaitement mais je ne dois pas mettre les valeurs pour le storePassword, et keyPassworddans mon référentiel. Je préférerais ne pas mettre storeFileet keyAliaslà non plus.

Existe-t-il un moyen de modifier le build.gradleafin qu'il obtienne les mots de passe d'une source externe (comme un fichier résidant uniquement sur mon ordinateur)?

Et bien sûr, le modifié build.gradledevrait être utilisable sur n'importe quel autre ordinateur (même si l'ordinateur n'a pas accès aux mots de passe).

J'utilise Android Studio et Mac OS X Maverics si cela compte.

La bonne chose à propos de Groovy est que vous pouvez librement mélanger du code Java, et il est assez facile à lire dans un fichier clé / valeur en utilisant java.util.Properties. Il existe peut-être un moyen encore plus simple d'utiliser Groovy idiomatique, mais Java est toujours assez simple.

Créez un keystore.propertiesfichier (dans cet exemple, dans le répertoire racine de votre projet à côté de settings.gradle, bien que vous puissiez le placer où vous le souhaitez:

storePassword=...
keyPassword=...
keyAlias=...
storeFile=...

Ajoutez ceci à votre build.gradle:

allprojects {
    afterEvaluate { project ->
        def propsFile = rootProject.file('keystore.properties')
        def configName = 'release'

        if (propsFile.exists() && android.signingConfigs.hasProperty(configName)) {
            def props = new Properties()
            props.load(new FileInputStream(propsFile))
            android.signingConfigs[configName].storeFile = file(props['storeFile'])
            android.signingConfigs[configName].storePassword = props['storePassword']
            android.signingConfigs[configName].keyAlias = props['keyAlias']
            android.signingConfigs[configName].keyPassword = props['keyPassword']
        }
    }
}

Alternativement, si vous souhaitez appliquer la réponse de Scott Barta d'une manière plus similaire au code de gradle généré automatiquement, vous pouvez créer un keystore.propertiesfichier dans le dossier racine de votre projet:

storePassword=my.keystore
keyPassword=key_password
keyAlias=my_key_alias
storeFile=store_file  

et modifiez votre code de note pour:

// Load keystore
def keystorePropertiesFile = rootProject.file("keystore.properties");
def keystoreProperties = new Properties()
keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

...

android{

    ...

    signingConfigs {
        release {
            storeFile file(keystoreProperties['storeFile'])
            storePassword keystoreProperties['storePassword']
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
        }
    }

    ...

}

Vous pouvez stocker ce fichier de propriétés à la racine de votre module, auquel cas omettez simplement rootProject, et vous pouvez également modifier ce code pour avoir plusieurs ensembles de propriétés pour différents keystores et alias de clé.

Le moyen le plus simple est de créer un ~/.gradle/gradle.propertiesfichier.

ANDROID_STORE_PASSWORD=hunter2
ANDROID_KEY_PASSWORD=hunter2

Ensuite, votre build.gradlefichier peut ressembler à ceci:

android {
    signingConfigs {
        release {
            storeFile file('yourfile.keystore')
            storePassword ANDROID_STORE_PASSWORD
            keyAlias 'youralias'
            keyPassword ANDROID_KEY_PASSWORD
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Après avoir lu quelques liens:

http://blog.macromates.com/2006/keychain-access-from-shell/ http://www.thoughtworks.com/es/insights/blog/signing-open-source-android-apps-without-disclosing- mots de passe

Puisque vous utilisez Mac OSX, vous pouvez utiliser l'accès au trousseau pour stocker vos mots de passe.

Puis dans vos scripts gradle:

/* Get password from Mac OSX Keychain */
def getPassword(String currentUser, String keyChain) {
    def stdout = new ByteArrayOutputStream()
    def stderr = new ByteArrayOutputStream()
    exec {
        commandLine 'security', '-q', 'find-generic-password', '-a', currentUser, '-gl', keyChain
        standardOutput = stdout
        errorOutput = stderr
        ignoreExitValue true
    }
    //noinspection GroovyAssignabilityCheck
    (stderr.toString().trim() =~ /password: '(.*)'/)[0][1]
}

Utilisez comme ceci:

getPassword (currentUser, "Android_Store_Password")

/* Plugins */
apply plugin: 'com.android.application'

/* Variables */
ext.currentUser = System.getenv("USER")
ext.userHome = System.getProperty("user.home")
ext.keystorePath = 'KEY_STORE_PATH'

/* Signing Configs */
android {  
    signingConfigs {
        release {
            storeFile file(userHome + keystorePath + project.name)
            storePassword getPassword(currentUser, "ANDROID_STORE_PASSWORD")
            keyAlias 'jaredburrows'
            keyPassword getPassword(currentUser, "ANDROID_KEY_PASSWORD")
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Voilà comment je fais. Utiliser des variables d'environnement

  signingConfigs {
    release {
        storeFile file(System.getenv("KEYSTORE"))
        storePassword System.getenv("KEYSTORE_PASSWORD")
        keyAlias System.getenv("KEY_ALIAS")
        keyPassword System.getenv("KEY_PASSWORD")
    }

Il est possible de prendre n'importe quel projet de gradle Android Studio existant et de le construire / signer à partir de la ligne de commande sans modifier aucun fichier. Cela le rend très agréable pour stocker votre projet dans le contrôle de version tout en gardant vos clés et mots de passe séparés et non dans votre fichier build.gradle:

./gradlew assembleRelease -Pandroid.injected.signing.store.file=$KEYFILE -Pandroid.injected.signing.store.password=$STORE_PASSWORD -Pandroid.injected.signing.key.alias=$KEY_ALIAS -Pandroid.injected.signing.key.password=$KEY_PASSWORD

La réponse acceptée utilise un fichier pour contrôler le fichier de clés à utiliser pour signer l'APK qui réside dans le même dossier racine du projet. Lorsque nous utilisons des vcs comme Git , cela pourrait être une mauvaise chose lorsque nous oublions d'ajouter le fichier de propriétés à la liste des ignorés. Parce que nous divulguerons notre mot de passe au monde. Les problèmes persistent.

Au lieu de créer le fichier de propriétés dans le même répertoire dans notre projet, nous devrions le créer à l'extérieur. Nous le faisons à l'extérieur en utilisant le fichier gradle.properties.

Voici les étapes:

1.Modifiez ou créez gradle.properties sur votre projet racine et ajoutez le code suivant, n'oubliez pas de modifier le chemin avec le vôtre:

AndroidProject.signing=/your/path/androidproject.properties  

2.Créez androidproject.properties dans / votre / chemin / et ajoutez-y le code suivant, n'oubliez pas de changer /your/path/to/android.keystore en chemin de votre keystore:

STORE_FILE=/your/path/to/android.keystore  
STORE_PASSWORD=yourstorepassword  
KEY_ALIAS=yourkeyalias  
KEY_PASSWORD=yourkeypassword  

3.Dans votre module d'application build.gradle (pas la racine de votre projet build.gradle), ajoutez le code suivant s'il n'existe pas ou ajustez-le:

signingConfigs {  
     release  
   }  
   buildTypes {  
   debug {  
     debuggable true  
   }  
   release {  
     minifyEnabled true  
     proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
     signingConfig signingConfigs.release  
   }  
 }  

4.Ajoutez le code suivant sous le code à l'étape 3:

if (project.hasProperty("AndroidProject.signing")  
     && new File(project.property("AndroidProject.signing").toString()).exists()) {  
     def Properties props = new Properties()  
     def propFile = new File(project.property("AndroidProject.signing").toString())  
     if(propFile.canRead()) {  
      props.load(new FileInputStream(propFile))  
      if (props!=null && props.containsKey('STORE_FILE') && props.containsKey('STORE_PASSWORD') &&  
         props.containsKey('KEY_ALIAS') && props.containsKey('KEY_PASSWORD')) {  
         android.signingConfigs.release.storeFile = file(props['STORE_FILE'])  
         android.signingConfigs.release.storePassword = props['STORE_PASSWORD']  
         android.signingConfigs.release.keyAlias = props['KEY_ALIAS']  
         android.signingConfigs.release.keyPassword = props['KEY_PASSWORD']  
      } else {  
         println 'androidproject.properties found but some entries are missing'  
         android.buildTypes.release.signingConfig = null  
      }  
     } else {  
            println 'androidproject.properties file not found'  
          android.buildTypes.release.signingConfig = null  
     }  
   }  

Ce code recherchera la propriété AndroidProject.signing dans gradle.properties à partir de l' étape 1 . Si la propriété est trouvée, elle traduira la valeur de la propriété en chemin de fichier pointant vers androidproject.properties que nous créons à l' étape 2 . Ensuite, toute la valeur de propriété de celle-ci sera utilisée comme configuration de signature pour notre build.gradle.

Maintenant, nous n'avons plus à nous inquiéter du risque d'exposer le mot de passe de notre keystore.

En savoir plus sur Signature de l'apk Android sans mettre les informations du keystore dans build.gradle

Pour ceux qui cherchent à mettre leurs informations d'identification dans un fichier JSON externe et à le lire à partir du gradle, voici ce que j'ai fait:

mon_projet / credentials.json:

{
    "android": {
        "storeFile": "/path/to/acuity.jks",
        "storePassword": "your_store_password",
        "keyAlias": "your_android_alias",
        "keyPassword": "your_key_password"
    }
}

mon_projet / android / app / build.gradle

// ...
signingConfigs {
        release {

            def credsFilePath = file("../../credentials.json").toString()
            def credsFile = new File(credsFilePath, "").getText('UTF-8')
            def json = new groovy.json.JsonSlurper().parseText(credsFile)
            storeFile file(json.android.storeFile)
            storePassword = json.android.storePassword
            keyAlias = json.android.keyAlias
            keyPassword = json.android.keyPassword
        }
        ...
        buildTypes {
            release {
                signingConfig signingConfigs.release //I added this
                // ...
            }
        }
    }
// ...
}

La raison pour laquelle j'ai choisi un .jsontype de fichier, et non un .propertiestype de fichier (comme dans la réponse acceptée), est que je voulais également stocker d'autres données (d'autres propriétés personnalisées dont j'avais besoin) dans ce même fichier ( my_project/credentials.json), tout en continuant à analyser progressivement le signer également des informations à partir de ce fichier.

Cette question a reçu de nombreuses réponses valides, mais je voulais partager mon code qui peut être utile pour les responsables de la bibliothèque , car il laisse l'original build.gradleassez propre .

J'ajoute un dossier au répertoire du module que je gitignore. Cela ressemble à ceci:

/signing
    /keystore.jks
    /signing.gradle
    /signing.properties

keystore.jkset signing.propertiesdevrait être explicite. Et signing.gradleressemble à ceci:

def propsFile = file('signing/signing.properties')
def buildType = "release"

if (!propsFile.exists()) throw new IllegalStateException("signing/signing.properties file missing")

def props = new Properties()
props.load(new FileInputStream(propsFile))

def keystoreFile = file("signing/keystore.jks")
if (!keystoreFile.exists()) throw new IllegalStateException("signing/keystore.jks file missing")

android.signingConfigs.create(buildType, {
    storeFile = keystoreFile
    storePassword = props['storePassword']
    keyAlias = props['keyAlias']
    keyPassword = props['keyPassword']
})

android.buildTypes[buildType].signingConfig = android.signingConfigs[buildType]

Et l'original build.gradle

apply plugin: 'com.android.application'
if (project.file('signing/signing.gradle').exists()) {
    apply from: 'signing/signing.gradle'
}

android {
    compileSdkVersion 27
    defaultConfig {
        applicationId ...
    }
}

dependencies {
    implementation ...
}

Comme vous pouvez le voir, vous n'avez pas du tout à spécifier les buildTypes, si l'utilisateur a accès à un signingrépertoire valide , il le met simplement dans le module et il peut créer une application de version signée valide, sinon cela fonctionne juste pour lui comme ce serait normalement le cas.

Vous pouvez demander des mots de passe à partir de la ligne de commande:

...

signingConfigs {
  if (gradle.startParameter.taskNames.any {it.contains('Release') }) {
    release {
      storeFile file("your.keystore")
      storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
      keyAlias "key-alias"
      keyPassword new String(System.console().readPassword("\n\$ Enter keys password: "))
    } 
  } else {
    //Here be dragons: unreachable else-branch forces Gradle to create
    //install...Release tasks.
    release {
      keyAlias 'dummy'
      keyPassword 'dummy'
      storeFile file('dummy')
      storePassword 'dummy'
    } 
  }
}

...

buildTypes {
  release {

    ...

    signingConfig signingConfigs.release
  }

  ...
}

...

Cette réponse est apparue précédemment: https://stackoverflow.com/a/33765572/3664487

Mon mot de passe contenait un caractère spécial dont le signe dollar $ et je devais l'échapper dans le fichier gradle.properties. Après cela, la signature a fonctionné pour moi.