Masuk APK tanpa memasukkan info keystore di build.gradle

Saya mencoba mengatur proses penandatanganan sehingga kata sandi dan kata sandi kunci keystore tidak disimpan dalam file proyek build.gradle.

Saat ini saya memiliki yang berikut di build.gradle:

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

    buildTypes {
        release {
            signingConfig signingConfigs.release            
        }
    }
}

Ini berfungsi dengan baik tetapi saya tidak harus meletakkan nilai untuk storePassword, dan keyPassworddi repositori saya. Saya lebih suka untuk tidak menaruh storeFiledan di keyAliassana juga.

Apakah ada cara untuk mengubah build.gradlesehingga akan mendapatkan kata sandi dari beberapa sumber eksternal (seperti file yang hanya berada di komputer saya)?

Dan tentu saja, yang diubah build.gradleharus dapat digunakan di komputer lain (bahkan jika komputer tidak memiliki akses ke kata sandi).

Saya menggunakan Android Studio dan di Mac OS X Maverics jika itu penting.

Yang menyenangkan tentang Groovy adalah Anda dapat dengan bebas mencampurkan kode Java, dan cukup mudah dibaca menggunakan file kunci / nilai java.util.Properties. Mungkin ada cara yang bahkan lebih mudah menggunakan Groovy idiomatik, tetapi Java masih cukup sederhana.

Buat keystore.propertiesfile (dalam contoh ini, di direktori root proyek Anda di sebelah settings.gradle, meskipun Anda dapat meletakkannya di mana pun Anda suka:

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

Tambahkan ini ke Anda 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']
        }
    }
}

Atau, jika Anda ingin menerapkan jawaban Scott Barta dengan cara yang lebih mirip dengan kode grader yang dibuat secara otomatis, Anda dapat membuat keystore.propertiesfile di folder root proyek Anda:

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

dan modifikasi kode gradle Anda ke:

// 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']
        }
    }

    ...

}

Anda dapat menyimpan file properti ini di root modul Anda, dalam hal ini hanya menghilangkan rootProject, dan Anda juga dapat memodifikasi kode ini untuk memiliki beberapa set properti untuk keystores dan alias kunci yang berbeda.

Cara termudah adalah membuat ~/.gradle/gradle.propertiesfile.

ANDROID_STORE_PASSWORD=hunter2
ANDROID_KEY_PASSWORD=hunter2

Maka build.gradlefile Anda dapat terlihat seperti ini:

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

Setelah membaca beberapa tautan:

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

Karena Anda menggunakan Mac OSX, Anda dapat menggunakan Akses Keychain untuk menyimpan kata sandi Anda.

Kemudian dalam skrip gradle Anda:

/* 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]
}

Gunakan seperti ini:

getPassword (pengguna saat ini, "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
        }
    }
}

Beginilah cara saya melakukannya. Gunakan Variabel Lingkungan

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

Dimungkinkan untuk mengambil proyek gradasi Android Studio yang ada dan membangun / menandatanganinya dari baris perintah tanpa mengedit file apa pun. Ini membuatnya sangat bagus untuk menyimpan proyek Anda dalam kontrol versi sambil menjaga kunci dan kata sandi Anda terpisah dan tidak dalam file build.gradle Anda:

./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

Jawaban yang diterima menggunakan file untuk mengontrol keystore mana yang akan digunakan untuk menandatangani APK yang berada di folder root proyek yang sama. Ketika kita menggunakan vcs seperti Git , bisa jadi hal yang buruk ketika kita lupa menambahkan file properti ke daftar abaikan. Karena kami akan mengungkapkan kata sandi kami kepada dunia. Masalahnya masih ada.

Alih-alih membuat file properti di direktori yang sama dalam proyek kami, kita harus membuatnya di luar. Kami membuatnya di luar dengan menggunakan file gradle.properties.

Berikut langkah-langkahnya:

1. Edit atau buat gradle.properties pada proyek root Anda dan tambahkan kode berikut, ingatlah untuk mengedit lintasan dengan Anda sendiri:

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

2.Buat properti androidproject.prop di / path / Anda / dan tambahkan kode berikut ke dalamnya, jangan lupa untuk mengubah /your/path/to/android.keystore ke jalur keystore Anda:

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

3.Dalam build.gradle modul aplikasi Anda (bukan build.gradle root proyek Anda) tambahkan kode berikut jika tidak ada atau sesuaikan dengannya:

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

4.Tambahkan kode berikut di bawah kode pada langkah 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  
     }  
   }  

Kode ini akan mencari properti AndroidProject.signing di gradle.properties dari langkah 1 . Jika properti ditemukan, itu akan menerjemahkan nilai properti sebagai path file yang menunjuk ke androidproject.properties yang kita buat di langkah 2 . Maka semua nilai properti darinya akan digunakan sebagai konfigurasi penandatanganan untuk build.gradle kami.

Sekarang kita tidak perlu khawatir lagi akan risiko mengekspos kata sandi kami.

Baca lebih lanjut di Signing Android apk tanpa memasukkan informasi keystore di build.gradle

Bagi yang ingin memasukkan kredensial mereka dalam file JSON eksternal dan membacanya dari gradle, inilah yang saya lakukan:

my_project / credentials.json:

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

my_project / 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
                // ...
            }
        }
    }
// ...
}

Alasan saya memilih .jsontipe file, dan bukan .propertiestipe file (seperti pada jawaban yang diterima), adalah karena saya ingin juga menyimpan data lain (properti khusus lain yang saya butuhkan) ke file yang sama ( my_project/credentials.json), dan masih harus mengurai parse menandatangani informasi dari dalam file itu juga.

Pertanyaan ini telah menerima banyak jawaban yang valid, tetapi saya ingin membagikan kode saya yang mungkin berguna bagi pengelola perpustakaan , karena meninggalkan yang asli build.gradlecukup bersih .

Saya menambahkan folder ke direktori modul yang saya gitignore. Ini terlihat seperti ini:

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

keystore.jksdan signing.propertiesharus jelas. Dan signing.gradleterlihat seperti ini:

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]

Dan yang asli 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 ...
}

Seperti yang Anda lihat, Anda tidak perlu menentukan buildTypes sama sekali, jika pengguna memiliki akses ke signingdirektori yang valid , ia hanya memasukkannya ke dalam modul dan ia dapat membangun aplikasi rilis yang ditandatangani yang valid, jika tidak, itu hanya berfungsi untuknya seperti itu biasanya akan dilakukan.

Anda dapat meminta kata sandi dari baris perintah:

...

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
  }

  ...
}

...

Jawaban ini sebelumnya muncul: https://stackoverflow.com/a/33765572/3664487

Kata sandi saya berisi karakter khusus yang masuk dolar $ dan saya harus menghindarinya dalam file gradle.properties. Setelah itu, penandatanganan bekerja untuk saya.