mirror of
https://gitlab.com/fdroid/fdroidserver.git
synced 2024-11-04 22:40:12 +01:00
787 lines
30 KiB
Python
Executable File
787 lines
30 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
|
||
import glob
|
||
import inspect
|
||
import logging
|
||
import optparse
|
||
import os
|
||
import re
|
||
import shutil
|
||
import sys
|
||
import tempfile
|
||
import textwrap
|
||
import unittest
|
||
import uuid
|
||
import yaml
|
||
import zipfile
|
||
import collections
|
||
import pathlib
|
||
from unittest import mock
|
||
from dataclasses import asdict
|
||
from datetime import datetime, timedelta
|
||
|
||
localmodule = os.path.realpath(
|
||
os.path.join(os.path.dirname(inspect.getfile(inspect.currentframe())), '..')
|
||
)
|
||
print('localmodule: ' + localmodule)
|
||
if localmodule not in sys.path:
|
||
sys.path.insert(0, localmodule)
|
||
|
||
import fdroidserver.build
|
||
import fdroidserver.common
|
||
import fdroidserver.metadata
|
||
import fdroidserver.scanner
|
||
from testcommon import TmpCwd, mkdtemp, mock_open_to_str
|
||
|
||
|
||
class ScannerTest(unittest.TestCase):
|
||
def setUp(self):
|
||
logging.basicConfig(level=logging.INFO)
|
||
self.basedir = os.path.join(localmodule, 'tests')
|
||
os.chdir(self.basedir)
|
||
self._td = mkdtemp()
|
||
self.testdir = self._td.name
|
||
|
||
def tearDown(self):
|
||
os.chdir(self.basedir)
|
||
self._td.cleanup()
|
||
|
||
def test_scan_source_files(self):
|
||
fdroidserver.scanner.options = mock.Mock()
|
||
fdroidserver.scanner.options.json = False
|
||
source_files = os.path.join(self.basedir, 'source-files')
|
||
projects = {
|
||
'OtakuWorld': 2,
|
||
'Zillode': 1,
|
||
'cn.wildfirechat.chat': 4,
|
||
'com.github.shadowsocks': 6,
|
||
'com.integreight.onesheeld': 11,
|
||
'com.jens.automation2': 2,
|
||
'firebase-suspect': 1,
|
||
'org.mozilla.rocket': 1,
|
||
'org.tasks': 2,
|
||
'realm': 1,
|
||
'se.manyver': 2,
|
||
}
|
||
for d in glob.glob(os.path.join(source_files, '*')):
|
||
build = fdroidserver.metadata.Build()
|
||
fatal_problems = fdroidserver.scanner.scan_source(d, build)
|
||
should = projects.get(os.path.basename(d), 0)
|
||
self.assertEqual(
|
||
should, fatal_problems, "%s should have %d errors!" % (d, should)
|
||
)
|
||
|
||
def test_get_gradle_compile_commands(self):
|
||
test_files = [
|
||
('source-files/fdroid/fdroidclient/build.gradle', 'yes', 18),
|
||
('source-files/com.nextcloud.client/build.gradle', 'generic', 28),
|
||
('source-files/com.kunzisoft.testcase/build.gradle', 'libre', 4),
|
||
('source-files/cn.wildfirechat.chat/chat/build.gradle', 'yes', 33),
|
||
('source-files/org.tasks/app/build.gradle.kts', 'generic', 39),
|
||
('source-files/at.bitfire.davdroid/build.gradle', 'standard', 16),
|
||
('source-files/se.manyver/android/app/build.gradle', 'indie', 29),
|
||
('source-files/osmandapp/osmand/build.gradle', 'free', 5),
|
||
('source-files/eu.siacs.conversations/build.gradle', 'free', 24),
|
||
('source-files/org.mozilla.rocket/app/build.gradle', 'focus', 42),
|
||
('source-files/com.jens.automation2/app/build.gradle', 'fdroidFlavor', 8),
|
||
]
|
||
|
||
for f, flavor, count in test_files:
|
||
i = 0
|
||
build = fdroidserver.metadata.Build()
|
||
build.gradle = [flavor]
|
||
regexs = fdroidserver.scanner.get_gradle_compile_commands(build)
|
||
with open(f, encoding='utf-8') as fp:
|
||
for line in fp.readlines():
|
||
for regex in regexs:
|
||
m = regex.match(line)
|
||
if m:
|
||
i += 1
|
||
self.assertEqual(count, i)
|
||
|
||
def test_scan_source_files_sneaky_maven(self):
|
||
"""Check for sneaking in banned maven repos"""
|
||
os.chdir(self.testdir)
|
||
fdroidserver.scanner.config = None
|
||
fdroidserver.scanner.options = mock.Mock()
|
||
fdroidserver.scanner.options.json = True
|
||
with open('build.gradle', 'w', encoding='utf-8') as fp:
|
||
fp.write(
|
||
textwrap.dedent(
|
||
"""
|
||
maven {
|
||
"https://jitpack.io"
|
||
url 'https://maven.fabric.io/public'
|
||
}
|
||
maven {
|
||
"https://maven.google.com"
|
||
setUrl('https://evilcorp.com/maven')
|
||
}
|
||
"""
|
||
)
|
||
)
|
||
count = fdroidserver.scanner.scan_source(self.testdir)
|
||
self.assertEqual(2, count, 'there should be this many errors')
|
||
|
||
def test_scan_source_file_types(self):
|
||
"""Build product files are not allowed, test they are detected
|
||
|
||
This test runs as if `fdroid build` running to test the
|
||
difference between absolute and relative paths.
|
||
|
||
"""
|
||
build_dir = os.path.join('build', 'fake.app')
|
||
abs_build_dir = os.path.join(self.testdir, build_dir)
|
||
os.makedirs(abs_build_dir, exist_ok=True)
|
||
os.chdir(abs_build_dir)
|
||
|
||
fdroidserver.scanner.config = None
|
||
fdroidserver.scanner.options = mock.Mock()
|
||
fdroidserver.scanner.options.json = True
|
||
|
||
keep = [
|
||
'arg.jar',
|
||
'ascii.out',
|
||
'baz.so',
|
||
'classes.dex',
|
||
'sqlcipher.aar',
|
||
'static.a',
|
||
'src/test/resources/classes.dex',
|
||
]
|
||
remove = ['gradle-wrapper.jar', 'gradlew', 'gradlew.bat']
|
||
os.makedirs('src/test/resources', exist_ok=True)
|
||
for f in keep + remove:
|
||
with open(f, 'w') as fp:
|
||
fp.write('placeholder')
|
||
self.assertTrue(os.path.exists(f))
|
||
binaries = ['binary.out', 'fake.png', 'snippet.png']
|
||
with open('binary.out', 'wb') as fp:
|
||
fp.write(b'\x00\x00')
|
||
fp.write(uuid.uuid4().bytes)
|
||
shutil.copyfile('binary.out', 'fake.png')
|
||
os.chmod('fake.png', 0o755)
|
||
os.system('ls -l binary.out')
|
||
with open('snippet.png', 'wb') as fp:
|
||
fp.write(
|
||
b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00'
|
||
b'\x000\x08\x06\x00\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sB'
|
||
b'IT\x08\x08\x08\x08|\x08d\x88\x00\x00\x00\tpHYs\x00\x00\n'
|
||
b'a\x00\x00\na\x01\xfc\xccJ%\x00\x00\x00\x19tEXtSoftware'
|
||
)
|
||
os.chmod('snippet.png', 0o755)
|
||
os.system('ls -l fake.png')
|
||
|
||
# run scanner as if from `fdroid build`
|
||
os.chdir(self.testdir)
|
||
json_per_build = fdroidserver.scanner.MessageStore()
|
||
count = fdroidserver.scanner.scan_source(
|
||
build_dir, json_per_build=json_per_build
|
||
)
|
||
self.assertEqual(6, count, 'there should be this many errors')
|
||
os.chdir(build_dir)
|
||
|
||
for f in keep + binaries:
|
||
self.assertTrue(os.path.exists(f), f + ' should still be there')
|
||
for f in remove:
|
||
self.assertFalse(os.path.exists(f), f + ' should have been removed')
|
||
|
||
json_per_build_asdict = asdict(json_per_build)
|
||
files = dict()
|
||
for section in ('errors', 'infos', 'warnings'):
|
||
files[section] = []
|
||
for msg, f in json_per_build_asdict[section]:
|
||
files[section].append(f)
|
||
|
||
self.assertFalse(
|
||
'ascii.out' in files['errors'], 'ASCII .out file is not an error'
|
||
)
|
||
self.assertFalse(
|
||
'snippet.png' in files['errors'], 'executable valid image is not an error'
|
||
)
|
||
|
||
self.assertTrue('arg.jar' in files['errors'], 'all JAR files are errors')
|
||
self.assertTrue('baz.so' in files['errors'], 'all .so files are errors')
|
||
self.assertTrue(
|
||
'binary.out' in files['errors'], 'a binary .out file is an error'
|
||
)
|
||
self.assertTrue(
|
||
'classes.dex' in files['errors'], 'all classes.dex files are errors'
|
||
)
|
||
self.assertTrue('sqlcipher.aar' in files['errors'], 'all AAR files are errors')
|
||
self.assertTrue('static.a' in files['errors'], 'all .a files are errors')
|
||
|
||
self.assertTrue(
|
||
'fake.png' in files['warnings'],
|
||
'a random binary that is executable that is not an image is a warning',
|
||
)
|
||
self.assertTrue(
|
||
'src/test/resources/classes.dex' in files['warnings'],
|
||
'suspicious file but in a test dir is a warning',
|
||
)
|
||
|
||
for f in remove:
|
||
self.assertTrue(
|
||
f in files['infos'], '%s should be removed with an info message' % f
|
||
)
|
||
|
||
def test_build_local_scanner(self):
|
||
"""`fdroid build` calls scanner functions, test them here"""
|
||
os.chdir(self.testdir)
|
||
config = dict()
|
||
fdroidserver.common.fill_config_defaults(config)
|
||
fdroidserver.common.config = config
|
||
fdroidserver.build.config = config
|
||
fdroidserver.build.options = mock.Mock()
|
||
fdroidserver.build.options.json = False
|
||
fdroidserver.build.options.scan_binary = False
|
||
fdroidserver.build.options.notarball = True
|
||
fdroidserver.build.options.skipscan = False
|
||
fdroidserver.scanner.options = fdroidserver.build.options
|
||
|
||
app = fdroidserver.metadata.App()
|
||
app.id = 'mocked.app.id'
|
||
build = fdroidserver.metadata.Build()
|
||
build.commit = '1.0'
|
||
build.output = app.id + '.apk'
|
||
build.scanignore = ['baz.so', 'foo.aar']
|
||
build.versionCode = 1
|
||
build.versionName = '1.0'
|
||
vcs = mock.Mock()
|
||
|
||
for f in ('baz.so', 'foo.aar', 'gradle-wrapper.jar'):
|
||
with open(f, 'w') as fp:
|
||
fp.write('placeholder')
|
||
self.assertTrue(os.path.exists(f))
|
||
|
||
with open('build.xml', 'w', encoding='utf-8') as fp:
|
||
fp.write(
|
||
textwrap.dedent(
|
||
"""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||
<project basedir="." default="clean" name="mockapp">
|
||
<target name="release"/>
|
||
<target name="clean"/>
|
||
</project>"""
|
||
)
|
||
)
|
||
|
||
def make_fake_apk(output, build):
|
||
with open(build.output, 'w') as fp:
|
||
fp.write('APK PLACEHOLDER')
|
||
return output
|
||
|
||
with mock.patch('fdroidserver.common.replace_build_vars', wraps=make_fake_apk):
|
||
with mock.patch('fdroidserver.common.get_native_code', return_value='x86'):
|
||
with mock.patch(
|
||
'fdroidserver.common.get_apk_id',
|
||
return_value=(app.id, build.versionCode, build.versionName),
|
||
):
|
||
with mock.patch(
|
||
'fdroidserver.common.is_apk_and_debuggable', return_value=False
|
||
):
|
||
fdroidserver.build.build_local(
|
||
app,
|
||
build,
|
||
vcs,
|
||
build_dir=self.testdir,
|
||
output_dir=self.testdir,
|
||
log_dir=None,
|
||
srclib_dir=None,
|
||
extlib_dir=None,
|
||
tmp_dir=None,
|
||
force=False,
|
||
onserver=False,
|
||
refresh=False,
|
||
)
|
||
self.assertTrue(os.path.exists('baz.so'))
|
||
self.assertTrue(os.path.exists('foo.aar'))
|
||
self.assertFalse(os.path.exists('gradle-wrapper.jar'))
|
||
|
||
def test_gradle_maven_url_regex(self):
|
||
"""Check the regex can find all the cases"""
|
||
with open(os.path.join(self.basedir, 'gradle-maven-blocks.yaml')) as fp:
|
||
data = yaml.safe_load(fp)
|
||
|
||
urls = []
|
||
for entry in data:
|
||
found = False
|
||
for m in fdroidserver.scanner.MAVEN_URL_REGEX.findall(entry):
|
||
urls.append(m)
|
||
found = True
|
||
self.assertTrue(found, 'this block should produce a URL:\n' + entry)
|
||
self.assertEqual(len(data), len(urls), 'each data example should produce a URL')
|
||
|
||
def test_scan_gradle_file_with_multiple_problems(self):
|
||
"""Check that the scanner can handle scandelete with gradle files with multiple problems"""
|
||
os.chdir(self.testdir)
|
||
fdroidserver.scanner.config = None
|
||
fdroidserver.scanner.options = mock.Mock()
|
||
build = fdroidserver.metadata.Build()
|
||
build.scandelete = ['build.gradle']
|
||
with open('build.gradle', 'w', encoding='utf-8') as fp:
|
||
fp.write(
|
||
textwrap.dedent(
|
||
"""
|
||
maven {
|
||
url 'https://maven.fabric.io/public'
|
||
}
|
||
maven {
|
||
url 'https://evilcorp.com/maven'
|
||
}
|
||
"""
|
||
)
|
||
)
|
||
count = fdroidserver.scanner.scan_source(self.testdir, build)
|
||
self.assertFalse(os.path.exists("build.gradle"))
|
||
self.assertEqual(0, count, 'there should be this many errors')
|
||
|
||
def test_get_embedded_classes(self):
|
||
config = dict()
|
||
fdroidserver.common.config = config
|
||
fdroidserver.common.fill_config_defaults(config)
|
||
for f in (
|
||
'apk.embedded_1.apk',
|
||
'bad-unicode-πÇÇ现代通用字-български-عربي1.apk',
|
||
'janus.apk',
|
||
'minimal_targetsdk_30_unsigned.apk',
|
||
'no_targetsdk_minsdk1_unsigned.apk',
|
||
'org.bitbucket.tickytacky.mirrormirror_1.apk',
|
||
'org.bitbucket.tickytacky.mirrormirror_2.apk',
|
||
'org.bitbucket.tickytacky.mirrormirror_3.apk',
|
||
'org.bitbucket.tickytacky.mirrormirror_4.apk',
|
||
'org.dyndns.fules.ck_20.apk',
|
||
'SpeedoMeterApp.main_1.apk',
|
||
'urzip.apk',
|
||
'urzip-badcert.apk',
|
||
'urzip-badsig.apk',
|
||
'urzip-release.apk',
|
||
'urzip-release-unsigned.apk',
|
||
'repo/com.example.test.helloworld_1.apk',
|
||
'repo/com.politedroid_3.apk',
|
||
'repo/com.politedroid_4.apk',
|
||
'repo/com.politedroid_5.apk',
|
||
'repo/com.politedroid_6.apk',
|
||
'repo/duplicate.permisssions_9999999.apk',
|
||
'repo/info.zwanenburg.caffeinetile_4.apk',
|
||
'repo/no.min.target.sdk_987.apk',
|
||
'repo/obb.main.oldversion_1444412523.apk',
|
||
'repo/obb.mainpatch.current_1619_another-release-key.apk',
|
||
'repo/obb.mainpatch.current_1619.apk',
|
||
'repo/obb.main.twoversions_1101613.apk',
|
||
'repo/obb.main.twoversions_1101615.apk',
|
||
'repo/obb.main.twoversions_1101617.apk',
|
||
'repo/souch.smsbypass_9.apk',
|
||
'repo/urzip-; Рахма́, [rɐxˈmanʲɪnəf] سيرجي_رخمانينوف 谢·.apk',
|
||
'repo/v1.v2.sig_1020.apk',
|
||
):
|
||
self.assertNotEqual(
|
||
set(),
|
||
fdroidserver.scanner.get_embedded_classes(f),
|
||
'should return results for ' + f,
|
||
)
|
||
|
||
def test_get_embedded_classes_empty_archives(self):
|
||
config = dict()
|
||
fdroidserver.common.config = config
|
||
fdroidserver.common.fill_config_defaults(config)
|
||
print('basedir')
|
||
for f in (
|
||
'Norway_bouvet_europe_2.obf.zip',
|
||
'repo/fake.ota.update_1234.zip',
|
||
):
|
||
self.assertEqual(
|
||
set(),
|
||
fdroidserver.scanner.get_embedded_classes(f),
|
||
'should return not results for ' + f,
|
||
)
|
||
|
||
@unittest.skipIf(
|
||
sys.hexversion < 0x03090000, 'Python < 3.9 has a limited zipfile.is_zipfile()'
|
||
)
|
||
def test_get_embedded_classes_secret_apk(self):
|
||
"""Try to hide an APK+DEX in an APK and see if we can find it"""
|
||
config = dict()
|
||
fdroidserver.common.config = config
|
||
fdroidserver.common.fill_config_defaults(config)
|
||
apk = 'urzip.apk'
|
||
mapzip = 'Norway_bouvet_europe_2.obf.zip'
|
||
secretfile = os.path.join(
|
||
self.basedir, 'org.bitbucket.tickytacky.mirrormirror_1.apk'
|
||
)
|
||
with tempfile.TemporaryDirectory() as tmpdir:
|
||
shutil.copy(apk, tmpdir)
|
||
shutil.copy(mapzip, tmpdir)
|
||
os.chdir(tmpdir)
|
||
with zipfile.ZipFile(mapzip, 'a') as zipfp:
|
||
zipfp.write(secretfile, 'secretapk')
|
||
with zipfile.ZipFile(apk) as readfp:
|
||
with readfp.open('classes.dex') as cfp:
|
||
zipfp.writestr('secretdex', cfp.read())
|
||
with zipfile.ZipFile(apk, 'a') as zipfp:
|
||
zipfp.write(mapzip)
|
||
|
||
cls = fdroidserver.scanner.get_embedded_classes(apk)
|
||
self.assertTrue(
|
||
'org/bitbucket/tickytacky/mirrormirror/MainActivity' in cls,
|
||
'this should find the classes in the hidden, embedded APK',
|
||
)
|
||
self.assertTrue(
|
||
'DEX file with fake name: secretdex' in cls,
|
||
'badly named embedded DEX fils should throw an error',
|
||
)
|
||
self.assertTrue(
|
||
'ZIP file without proper file extension: secretapk' in cls,
|
||
'badly named embedded ZIPs should throw an error',
|
||
)
|
||
|
||
|
||
class Test_scan_binary(unittest.TestCase):
|
||
def setUp(self):
|
||
self.basedir = os.path.join(localmodule, 'tests')
|
||
config = dict()
|
||
fdroidserver.common.fill_config_defaults(config)
|
||
fdroidserver.common.config = config
|
||
fdroidserver.common.options = mock.Mock()
|
||
|
||
fdroidserver.scanner._SCANNER_TOOL = mock.Mock()
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs = {}
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs['err_code_signatures'] = {
|
||
"java/lang/Object": re.compile(
|
||
r'.*java/lang/Object', re.IGNORECASE | re.UNICODE
|
||
)
|
||
}
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs['warn_code_signatures'] = {}
|
||
|
||
def test_code_signature_match(self):
|
||
apkfile = os.path.join(self.basedir, 'no_targetsdk_minsdk1_unsigned.apk')
|
||
self.assertEqual(
|
||
1,
|
||
fdroidserver.scanner.scan_binary(apkfile),
|
||
"Did not find expected code signature '{}' in binary '{}'".format(
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs[
|
||
'err_code_signatures'
|
||
].values(),
|
||
apkfile,
|
||
),
|
||
)
|
||
|
||
@unittest.skipIf(
|
||
sys.version_info < (3, 9),
|
||
"Our implementation for traversing zip files will silently fail to work"
|
||
"on older python versions, also see: "
|
||
"https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1110#note_932026766",
|
||
)
|
||
def test_bottom_level_embedded_apk_code_signature(self):
|
||
apkfile = os.path.join(self.basedir, 'apk.embedded_1.apk')
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs['err_code_signatures'] = {
|
||
"org/bitbucket/tickytacky/mirrormirror/MainActivity": re.compile(
|
||
r'.*org/bitbucket/tickytacky/mirrormirror/MainActivity',
|
||
re.IGNORECASE | re.UNICODE,
|
||
)
|
||
}
|
||
|
||
self.assertEqual(
|
||
1,
|
||
fdroidserver.scanner.scan_binary(apkfile),
|
||
"Did not find expected code signature '{}' in binary '{}'".format(
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs[
|
||
'err_code_signatures'
|
||
].values(),
|
||
apkfile,
|
||
),
|
||
)
|
||
|
||
def test_top_level_signature_embedded_apk_present(self):
|
||
apkfile = os.path.join(self.basedir, 'apk.embedded_1.apk')
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs['err_code_signatures'] = {
|
||
"org/fdroid/ci/BuildConfig": re.compile(
|
||
r'.*org/fdroid/ci/BuildConfig', re.IGNORECASE | re.UNICODE
|
||
)
|
||
}
|
||
self.assertEqual(
|
||
1,
|
||
fdroidserver.scanner.scan_binary(apkfile),
|
||
"Did not find expected code signature '{}' in binary '{}'".format(
|
||
fdroidserver.scanner._SCANNER_TOOL.regexs[
|
||
'err_code_signatures'
|
||
].values(),
|
||
apkfile,
|
||
),
|
||
)
|
||
|
||
|
||
class Test_SignatureDataController(unittest.TestCase):
|
||
# __init__
|
||
def test_init(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
self.assertEqual(sdc.name, 'nnn')
|
||
self.assertEqual(sdc.filename, 'fff.yml')
|
||
self.assertEqual(sdc.cache_duration, timedelta(999999))
|
||
self.assertDictEqual(sdc.data, {})
|
||
|
||
# check_last_updated
|
||
def test_check_last_updated_ok(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.data['last_updated'] = datetime.utcnow().timestamp()
|
||
sdc.check_last_updated()
|
||
|
||
def test_check_last_updated_exception_cache_outdated(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.cache_duration = timedelta(days=7)
|
||
sdc.data['last_updated'] = (datetime.utcnow() - timedelta(days=30)).timestamp()
|
||
with self.assertRaises(fdroidserver.scanner.SignatureDataOutdatedException):
|
||
sdc.check_last_updated()
|
||
|
||
def test_check_last_updated_exception_not_string(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.data['last_updated'] = 'sepp'
|
||
with self.assertRaises(fdroidserver.scanner.SignatureDataMalformedException):
|
||
sdc.check_last_updated()
|
||
|
||
def test_check_last_updated_exception_not_iso_formatted_string(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.data['last_updated'] = '01/09/2002 10:11'
|
||
with self.assertRaises(fdroidserver.scanner.SignatureDataMalformedException):
|
||
sdc.check_last_updated()
|
||
|
||
def test_check_last_updated_no_exception_missing_when_last_updated_not_set(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.check_last_updated()
|
||
|
||
# check_data_version
|
||
def test_check_data_version_ok(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.data['version'] = fdroidserver.scanner.SCANNER_CACHE_VERSION
|
||
sdc.check_data_version()
|
||
|
||
def test_check_data_version_exception(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
with self.assertRaises(
|
||
fdroidserver.scanner.SignatureDataVersionMismatchException
|
||
):
|
||
sdc.check_data_version()
|
||
|
||
def test_load_ok(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
func_lfc = mock.Mock()
|
||
func_vd = mock.Mock()
|
||
func_clu = mock.Mock()
|
||
with mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.load_from_cache',
|
||
func_lfc,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.verify_data',
|
||
func_vd,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.check_last_updated',
|
||
func_clu,
|
||
):
|
||
sdc.load()
|
||
func_lfc.assert_called_once_with()
|
||
func_vd.assert_called_once_with()
|
||
func_clu.assert_called_once_with()
|
||
|
||
def test_load_initial_cache_miss(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
func_lfc = mock.Mock(
|
||
side_effect=fdroidserver.scanner.SignatureDataCacheMissException
|
||
)
|
||
func_lfd = mock.Mock()
|
||
with mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.load_from_cache',
|
||
func_lfc,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.load_from_defaults',
|
||
func_lfd,
|
||
):
|
||
sdc.load()
|
||
func_lfc.assert_called_once_with()
|
||
func_lfd.assert_called_once_with()
|
||
|
||
def test_load_cache_auto_refresh(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
func_lfc = mock.Mock()
|
||
func_vd = mock.Mock()
|
||
func_clu = mock.Mock(
|
||
side_effect=fdroidserver.scanner.SignatureDataOutdatedException()
|
||
)
|
||
func_fsfw = mock.Mock()
|
||
func_wtc = mock.Mock()
|
||
with mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.load_from_cache',
|
||
func_lfc,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.verify_data',
|
||
func_vd,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.check_last_updated',
|
||
func_clu,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.fetch_signatures_from_web',
|
||
func_fsfw,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.write_to_cache',
|
||
func_wtc,
|
||
):
|
||
sdc.load()
|
||
func_lfc.assert_called_once_with()
|
||
func_vd.assert_called_once_with()
|
||
func_clu.assert_called_once_with()
|
||
func_fsfw.assert_called_once_with()
|
||
func_wtc.assert_called_once_with()
|
||
|
||
def test_load_try_web_when_no_defaults(self):
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
func_lfc = mock.Mock(
|
||
side_effect=fdroidserver.scanner.SignatureDataCacheMissException()
|
||
)
|
||
func_lfd = mock.Mock(
|
||
side_effect=fdroidserver.scanner.SignatureDataNoDefaultsException()
|
||
)
|
||
func_fsfw = mock.Mock()
|
||
func_wtc = mock.Mock()
|
||
with mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.load_from_cache',
|
||
func_lfc,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.load_from_defaults',
|
||
func_lfd,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.fetch_signatures_from_web',
|
||
func_fsfw,
|
||
), mock.patch(
|
||
'fdroidserver.scanner.SignatureDataController.write_to_cache',
|
||
func_wtc,
|
||
):
|
||
sdc.load()
|
||
func_lfc.assert_called_once_with()
|
||
func_lfd.assert_called_once_with()
|
||
func_fsfw.assert_called_once_with()
|
||
func_wtc.assert_called_once_with()
|
||
|
||
@unittest.skipIf(
|
||
sys.version_info < (3, 9, 0),
|
||
"mock_open doesn't allow easy access to written data in older python versions",
|
||
)
|
||
def test_write_to_cache(self):
|
||
open_func = mock.mock_open()
|
||
sdc = fdroidserver.scanner.SignatureDataController(
|
||
'nnn', 'fff.yml', 'https://example.com/test.json'
|
||
)
|
||
sdc.data = {"mocked": "data"}
|
||
|
||
with mock.patch("builtins.open", open_func), mock.patch(
|
||
"fdroidserver.scanner._scanner_cachedir",
|
||
return_value=pathlib.Path('.'),
|
||
):
|
||
sdc.write_to_cache()
|
||
|
||
open_func.assert_called_with(pathlib.Path('fff.yml'), 'w', encoding="utf-8")
|
||
self.assertEqual(mock_open_to_str(open_func), """{\n "mocked": "data"\n}""")
|
||
|
||
|
||
class Test_ScannerTool(unittest.TestCase):
|
||
def test_load(self):
|
||
st = mock.Mock()
|
||
st.sdcs = [mock.Mock(), mock.Mock()]
|
||
fdroidserver.scanner.ScannerTool.load(st)
|
||
st.sdcs[0].load.assert_called_once_with()
|
||
st.sdcs[1].load.assert_called_once_with()
|
||
|
||
|
||
class Test_main(unittest.TestCase):
|
||
def setUp(self):
|
||
self.args = ["com.example.app", "local/additional.apk", "another.apk"]
|
||
self.exit_func = mock.Mock()
|
||
self.read_app_args_func = mock.Mock(return_value={})
|
||
self.scan_binary_func = mock.Mock(return_value=0)
|
||
|
||
def test_parsing_appid(self):
|
||
"""
|
||
This test verifies that app id get parsed correctly
|
||
(doesn't test how they get processed)
|
||
"""
|
||
self.args = ["com.example.app"]
|
||
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir), mock.patch(
|
||
"sys.exit", self.exit_func
|
||
), mock.patch("sys.argv", ["fdroid scanner", *self.args]), mock.patch(
|
||
"fdroidserver.common.read_app_args", self.read_app_args_func
|
||
), mock.patch(
|
||
"fdroidserver.scanner.scan_binary", self.scan_binary_func
|
||
):
|
||
fdroidserver.scanner.main()
|
||
|
||
self.exit_func.assert_not_called()
|
||
self.read_app_args_func.assert_called_once_with(
|
||
['com.example.app'], collections.OrderedDict(), True
|
||
)
|
||
self.scan_binary_func.assert_not_called()
|
||
|
||
def test_parsing_apkpath(self):
|
||
"""
|
||
This test verifies that apk paths get parsed correctly
|
||
(doesn't test how they get processed)
|
||
"""
|
||
self.args = ["local.application.apk"]
|
||
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir), mock.patch(
|
||
"sys.exit", self.exit_func
|
||
), mock.patch("sys.argv", ["fdroid scanner", *self.args]), mock.patch(
|
||
"fdroidserver.common.read_app_args", self.read_app_args_func
|
||
), mock.patch(
|
||
"fdroidserver.scanner.scan_binary", self.scan_binary_func
|
||
):
|
||
pathlib.Path(self.args[0]).touch()
|
||
fdroidserver.scanner.main()
|
||
|
||
self.exit_func.assert_not_called()
|
||
self.read_app_args_func.assert_not_called()
|
||
self.scan_binary_func.assert_called_once_with('local.application.apk')
|
||
|
||
|
||
if __name__ == "__main__":
|
||
os.chdir(os.path.dirname(__file__))
|
||
|
||
parser = optparse.OptionParser()
|
||
parser.add_option(
|
||
"-v",
|
||
"--verbose",
|
||
action="store_true",
|
||
default=False,
|
||
help="Spew out even more information than normal",
|
||
)
|
||
(fdroidserver.common.options, args) = parser.parse_args(['--verbose'])
|
||
|
||
newSuite = unittest.TestSuite()
|
||
newSuite.addTests(
|
||
[
|
||
unittest.makeSuite(ScannerTest),
|
||
unittest.makeSuite(Test_scan_binary),
|
||
unittest.makeSuite(Test_SignatureDataController),
|
||
unittest.makeSuite(Test_main),
|
||
]
|
||
)
|
||
unittest.main(failfast=False)
|