fdroidserver/publish.py

   1 #!/usr/bin/env python3
   2 #
   3 # publish.py - part of the FDroid server tools
   4 # Copyright (C) 2010-13, Ciaran Gultnieks, ciaran@ciarang.com
   5 # Copyright (C) 2013-2014 Daniel Martí <mvdan@mvdan.cc>
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU Affero General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU Affero General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Affero General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 import sys
  21 import os
  22 import shutil
  23 import md5
  24 import glob
  25 from argparse import ArgumentParser
  26 import logging
  27
  28 import common
  29 import metadata
  30 from common import FDroidPopen, SdkToolsPopen, BuildException
  31
  32 config = None
  33 options = None
  34
  35
  36 def main():
  37
  38     global config, options
  39
  40     # Parse command line...
  41     parser = ArgumentParser(usage="%(prog)s [options] "
  42                             "[APPID[:VERCODE] [APPID[:VERCODE] ...]]")
  43     common.setup_global_opts(parser)
  44     parser.add_argument("appid", nargs='*', help="app-id with optional versioncode in the form APPID[:VERCODE]")
  45     options = parser.parse_args()
  46
  47     config = common.read_config(options)
  48
  49     if not ('jarsigner' in config and 'keytool' in config):
  50         logging.critical('Java JDK not found! Install in standard location or set java_paths!')
  51         sys.exit(1)
  52
  53     log_dir = 'logs'
  54     if not os.path.isdir(log_dir):
  55         logging.info("Creating log directory")
  56         os.makedirs(log_dir)
  57
  58     tmp_dir = 'tmp'
  59     if not os.path.isdir(tmp_dir):
  60         logging.info("Creating temporary directory")
  61         os.makedirs(tmp_dir)
  62
  63     output_dir = 'repo'
  64     if not os.path.isdir(output_dir):
  65         logging.info("Creating output directory")
  66         os.makedirs(output_dir)
  67
  68     unsigned_dir = 'unsigned'
  69     if not os.path.isdir(unsigned_dir):
  70         logging.warning("No unsigned directory - nothing to do")
  71         sys.exit(1)
  72
  73     for f in [config['keystorepassfile'],
  74               config['keystore'],
  75               config['keypassfile']]:
  76         if not os.path.exists(f):
  77             logging.error("Config error - missing '{0}'".format(f))
  78             sys.exit(1)
  79
  80     # It was suggested at
  81     #    https://dev.guardianproject.info/projects/bazaar/wiki/FDroid_Audit
  82     # that a package could be crafted, such that it would use the same signing
  83     # key as an existing app. While it may be theoretically possible for such a
  84     # colliding package ID to be generated, it seems virtually impossible that
  85     # the colliding ID would be something that would be a) a valid package ID,
  86     # and b) a sane-looking ID that would make its way into the repo.
  87     # Nonetheless, to be sure, before publishing we check that there are no
  88     # collisions, and refuse to do any publishing if that's the case...
  89     allapps = metadata.read_metadata()
  90     vercodes = common.read_pkg_args(options.appid, True)
  91     allaliases = []
  92     for appid in allapps:
  93         m = md5.new()
  94         m.update(appid)
  95         keyalias = m.hexdigest()[:8]
  96         if keyalias in allaliases:
  97             logging.error("There is a keyalias collision - publishing halted")
  98             sys.exit(1)
  99         allaliases.append(keyalias)
 100     logging.info("{0} apps, {0} key aliases".format(len(allapps),
 101                                                     len(allaliases)))
 102
 103     # Process any apks that are waiting to be signed...
 104     for apkfile in sorted(glob.glob(os.path.join(unsigned_dir, '*.apk'))):
 105
 106         appid, vercode = common.apknameinfo(apkfile)
 107         apkfilename = os.path.basename(apkfile)
 108         if vercodes and appid not in vercodes:
 109             continue
 110         if appid in vercodes and vercodes[appid]:
 111             if vercode not in vercodes[appid]:
 112                 continue
 113         logging.info("Processing " + apkfile)
 114
 115         # There ought to be valid metadata for this app, otherwise why are we
 116         # trying to publish it?
 117         if appid not in allapps:
 118             logging.error("Unexpected {0} found in unsigned directory"
 119                           .format(apkfilename))
 120             sys.exit(1)
 121         app = allapps[appid]
 122
 123         if app.Binaries is not None:
 124
 125             # It's an app where we build from source, and verify the apk
 126             # contents against a developer's binary, and then publish their
 127             # version if everything checks out.
 128             # The binary should already have been retrieved during the build
 129             # process.
 130             srcapk = apkfile + ".binary"
 131
 132             # Compare our unsigned one with the downloaded one...
 133             compare_result = common.verify_apks(srcapk, apkfile, tmp_dir)
 134             if compare_result:
 135                 logging.error("...verification failed - publish skipped : "
 136                               + compare_result)
 137                 continue
 138
 139             # Success! So move the downloaded file to the repo, and remove
 140             # our built version.
 141             shutil.move(srcapk, os.path.join(output_dir, apkfilename))
 142             os.remove(apkfile)
 143
 144         else:
 145
 146             # It's a 'normal' app, i.e. we sign and publish it...
 147
 148             # Figure out the key alias name we'll use. Only the first 8
 149             # characters are significant, so we'll use the first 8 from
 150             # the MD5 of the app's ID and hope there are no collisions.
 151             # If a collision does occur later, we're going to have to
 152             # come up with a new alogrithm, AND rename all existing keys
 153             # in the keystore!
 154             if appid in config['keyaliases']:
 155                 # For this particular app, the key alias is overridden...
 156                 keyalias = config['keyaliases'][appid]
 157                 if keyalias.startswith('@'):
 158                     m = md5.new()
 159                     m.update(keyalias[1:])
 160                     keyalias = m.hexdigest()[:8]
 161             else:
 162                 m = md5.new()
 163                 m.update(appid)
 164                 keyalias = m.hexdigest()[:8]
 165             logging.info("Key alias: " + keyalias)
 166
 167             # See if we already have a key for this application, and
 168             # if not generate one...
 169             p = FDroidPopen([config['keytool'], '-list',
 170                              '-alias', keyalias, '-keystore', config['keystore'],
 171                              '-storepass:file', config['keystorepassfile']])
 172             if p.returncode != 0:
 173                 logging.info("Key does not exist - generating...")
 174                 p = FDroidPopen([config['keytool'], '-genkey',
 175                                  '-keystore', config['keystore'],
 176                                  '-alias', keyalias,
 177                                  '-keyalg', 'RSA', '-keysize', '2048',
 178                                  '-validity', '10000',
 179                                  '-storepass:file', config['keystorepassfile'],
 180                                  '-keypass:file', config['keypassfile'],
 181                                  '-dname', config['keydname']])
 182                 # TODO keypass should be sent via stdin
 183                 if p.returncode != 0:
 184                     raise BuildException("Failed to generate key")
 185
 186             # Sign the application...
 187             p = FDroidPopen([config['jarsigner'], '-keystore', config['keystore'],
 188                              '-storepass:file', config['keystorepassfile'],
 189                              '-keypass:file', config['keypassfile'], '-sigalg',
 190                              'SHA1withRSA', '-digestalg', 'SHA1',
 191                              apkfile, keyalias])
 192             # TODO keypass should be sent via stdin
 193             if p.returncode != 0:
 194                 raise BuildException("Failed to sign application")
 195
 196             # Zipalign it...
 197             p = SdkToolsPopen(['zipalign', '-v', '4', apkfile,
 198                                os.path.join(output_dir, apkfilename)])
 199             if p.returncode != 0:
 200                 raise BuildException("Failed to align application")
 201             os.remove(apkfile)
 202
 203         # Move the source tarball into the output directory...
 204         tarfilename = apkfilename[:-4] + '_src.tar.gz'
 205         tarfile = os.path.join(unsigned_dir, tarfilename)
 206         if os.path.exists(tarfile):
 207             shutil.move(tarfile, os.path.join(output_dir, tarfilename))
 208
 209         logging.info('Published ' + apkfilename)
 210
 211
 212 if __name__ == "__main__":
 213     main()