/* * Copyright © 2018-2019,2021-2022 Soren Stoutner . * * This file is part of Privacy Browser Android . * * Privacy Browser Android is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Privacy Browser Android is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Privacy Browser Android. If not, see . */ package com.stoutner.privacybrowser.helpers import android.content.res.AssetManager import java.io.BufferedReader import java.io.IOException import java.io.InputStreamReader import java.util.ArrayList import java.util.regex.Pattern class BlocklistHelper { companion object { // Describe the schema of the string array in each entry of the resource requests array list. const val REQUEST_DISPOSITION = 0 const val REQUEST_URL = 1 const val REQUEST_BLOCKLIST = 2 const val REQUEST_SUBLIST = 3 const val REQUEST_BLOCKLIST_ENTRIES = 4 const val REQUEST_BLOCKLIST_ORIGINAL_ENTRY = 5 // The request disposition options. const val REQUEST_DEFAULT = "0" const val REQUEST_ALLOWED = "1" const val REQUEST_THIRD_PARTY = "2" const val REQUEST_BLOCKED = "3" // The whitelists. const val MAIN_WHITELIST = "1" const val FINAL_WHITELIST = "2" const val DOMAIN_WHITELIST = "3" const val DOMAIN_INITIAL_WHITELIST = "4" const val DOMAIN_FINAL_WHITELIST = "5" const val THIRD_PARTY_WHITELIST = "6" const val THIRD_PARTY_DOMAIN_WHITELIST = "7" const val THIRD_PARTY_DOMAIN_INITIAL_WHITELIST = "8" // The blacklists. const val MAIN_BLACKLIST = "9" const val INITIAL_BLACKLIST = "10" const val FINAL_BLACKLIST = "11" const val DOMAIN_BLACKLIST = "12" const val DOMAIN_INITIAL_BLACKLIST = "13" const val DOMAIN_FINAL_BLACKLIST = "14" const val DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "15" const val THIRD_PARTY_BLACKLIST = "16" const val THIRD_PARTY_INITIAL_BLACKLIST = "17" const val THIRD_PARTY_DOMAIN_BLACKLIST = "18" const val THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST = "19" const val THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST = "20" const val THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "21" const val REGULAR_EXPRESSION_BLACKLIST = "22" } fun parseBlocklist(assetManager: AssetManager, blocklistName: String): ArrayList>> { // Initialize the header list. val headers: MutableList> = ArrayList() // 0. // Initialize the whitelists. val mainWhitelist: MutableList> = ArrayList() // 1. val finalWhitelist: MutableList> = ArrayList() // 2. val domainWhitelist: MutableList> = ArrayList() // 3. val domainInitialWhitelist: MutableList> = ArrayList() // 4. val domainFinalWhitelist: MutableList> = ArrayList() // 5. val thirdPartyWhitelist: MutableList> = ArrayList() // 6. val thirdPartyDomainWhitelist: MutableList> = ArrayList() // 7. val thirdPartyDomainInitialWhitelist: MutableList> = ArrayList() // 8. // Initialize the blacklists. val mainBlacklist: MutableList> = ArrayList() // 9. val initialBlacklist: MutableList> = ArrayList() // 10. val finalBlacklist: MutableList> = ArrayList() // 11. val domainBlacklist: MutableList> = ArrayList() // 12. val domainInitialBlacklist: MutableList> = ArrayList() // 13. val domainFinalBlacklist: MutableList> = ArrayList() // 14. val domainRegularExpressionBlacklist: MutableList> = ArrayList() // 15. val thirdPartyBlacklist: MutableList> = ArrayList() // 16. val thirdPartyInitialBlacklist: MutableList> = ArrayList() // 17. val thirdPartyDomainBlacklist: MutableList> = ArrayList() // 18. val thirdPartyDomainInitialBlacklist: MutableList> = ArrayList() // 19. val regularExpressionBlacklist: MutableList> = ArrayList() // 20. val thirdPartyRegularExpressionBlacklist: MutableList> = ArrayList() // 21. val thirdPartyDomainRegularExpressionBlacklist: MutableList> = ArrayList() // 22. // Populate the blocklists. The `try` is required by input stream reader. try { // Load the blocklist into a buffered reader. val bufferedReader = BufferedReader(InputStreamReader(assetManager.open(blocklistName))) // Create strings for storing the block list entries. var blocklistEntry: String var originalBlocklistEntry: String // Parse the block list. bufferedReader.forEachLine { // Store the original block list entry. originalBlocklistEntry = it // Remove any `^` from the block list entry. Privacy Browser does not process them in the interest of efficiency. blocklistEntry = it.replace("^", "") // Parse the entry. if (blocklistEntry.contains("##") || blocklistEntry.contains("#?#") || blocklistEntry.contains("#@#") || blocklistEntry.startsWith("[")) { // Entries that contain `##`, `#?#`, and `#@#` are for hiding elements in the main page's HTML. Entries that start with `[` describe the AdBlock compatibility level. // Do nothing. Privacy Browser does not currently use these entries. //Log.i("Blocklists", "Not added: " + blocklistEntry); } else if (blocklistEntry.contains("\$csp=script-src")) { // Ignore entries that contain `$csp=script-src`. // Do nothing. It is uncertain what this directive is even supposed to mean, and it is blocking entire websites like androidcentral.com. https://redmine.stoutner.com/issues/306. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else if (blocklistEntry.contains("\$websocket") || blocklistEntry.contains("\$third-party,websocket") || blocklistEntry.contains("\$script,websocket")) { // Ignore entries with `websocket`. // Do nothing. Privacy Browser does not differentiate between websocket requests and other requests and these entries cause a lot of false positives. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else if (blocklistEntry.startsWith("!")) { // Comment entries. if (blocklistEntry.startsWith("! Version:")) { // Get the list version number. val listVersion = arrayOf(blocklistEntry.substring(11)) // Store the list version in the headers list. headers.add(listVersion) } if (blocklistEntry.startsWith("! Title:")) { // Get the list title. val listTitle = arrayOf(blocklistEntry.substring(9)) // Store the list title in the headers list. headers.add(listTitle) } //Log.i("Blocklists", "Not added: " + blocklistEntry); } else if (blocklistEntry.startsWith("@@")) { // Entries that begin with `@@` are whitelists. // Remove the `@@` blocklistEntry = blocklistEntry.substring(2) // Strip out any initial `||`. Privacy Browser doesn't differentiate items that only match against the end of the domain name. if (blocklistEntry.startsWith("||")) { blocklistEntry = blocklistEntry.substring(2) } if (blocklistEntry.contains("$")) { // Filter entries. if (blocklistEntry.contains("~third-party")) { // Ignore entries that contain `~third-party`. // Do nothing. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else if (blocklistEntry.contains("third-party")) { // Third-party whitelist entries. if (blocklistEntry.contains("domain=")) { // Third-party domain whitelist entries. // Parse the entry. var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) var domains = filters.substring(filters.indexOf("domain=") + 7) if (domains.contains("~")) { // It is uncertain what a `~` domain means inside an `@@` entry. // Do Nothing //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else if (blocklistEntry.startsWith("|")) { // Third-party domain initial whitelist entries. // Strip out the initial `|`. entry = entry.substring(1) if (entry == "http://" || entry == "https://") { // Ignore generic entries. // Do nothing. These entries are designed for filter options that Privacy Browser does not use. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else { // Process third-party domain initial whitelist entries. // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } if (entry.contains("*")) { // Process a third-party domain initial whitelist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyDomainInitialWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + // " - " + originalBlocklistEntry); } else { // Process a third-party domain initial whitelist single entry. // Create a domain entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the third party domain initial whitelist. thirdPartyDomainInitialWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } } else { // Third-party domain entries. // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // three is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } // Remove any trailing `*` from the entry. if (entry.endsWith("*")) { entry = entry.substring(0, entry.length - 1) } if (entry.contains("*")) { // Process a third-party domain double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyDomainWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } else { // Process a third-party domain single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyDomainWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } } else { // Process third-party whitelist entries. // Parse the entry val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // There are three or more entries. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) if (thirdEntry.contains("*")) { // There are four or more entries. // Get the index of the wildcard. val thirdWildcardIndex = thirdEntry.indexOf("*") // Split the entry into components. val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) if (fourthEntry.contains("*")) { // Process a third-party whitelist quintuple entry. // Get the index of the wildcard. val fourthWildcardIndex = fourthEntry.indexOf("*") // Split the entry into components. val realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex) val fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1) // Create an entry string array. val quintupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyWhitelist.add(quintupleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + // realFourthEntry + " , " + fifthEntry + " - " + originalBlocklistEntry); } else { // Process a third-party whitelist quadruple entry. // Create an entry string array. val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyWhitelist.add(quadrupleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + // fourthEntry + " - " + originalBlocklistEntry); } } else { // Process a third-party whitelist triple entry. // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyWhitelist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + // originalBlocklistEntry); } } else { // Process a third-party whitelist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyWhitelist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a third-party whitelist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyWhitelist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + entry + " - " + originalBlocklistEntry); } } } else if (blocklistEntry.contains("domain=")) { // Process domain whitelist entries. // Parse the entry var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) var domains = filters.substring(filters.indexOf("domain=") + 7) if (entry.startsWith("|")) { // Initial domain whitelist entries. // Strip the initial `|`. entry = entry.substring(1) if (entry == "http://" || entry == "https://") { // Ignore generic entries. // Do nothing. These entries are designed for filter options that Privacy Browser does not use. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else { // Initial domain whitelist entry. // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a domain initial triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainInitialWhitelist.add(domainTripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + // thirdEntry + " - " + originalBlocklistEntry); } else { // Process a domain initial double entry. // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainInitialWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } } else { // Process a domain initial single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the whitelist. domainInitialWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } } else if (entry.endsWith("|")) { // Final domain whitelist entries. // Strip the `|` from the end of the entry. entry = entry.substring(0, entry.length - 1) // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } if (entry.contains("*")) { // Process a domain final whitelist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainFinalWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain final whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } else { // Process a domain final whitelist single entry. // create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the whitelist. domainFinalWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain final whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } else { // Standard domain whitelist entries with filters. if (domains.contains("~")) { // It is uncertain what a `~` domain means inside an `@@` entry. // Do Nothing //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else { // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // There are three or more entries. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) if (thirdEntry.contains("*")) { // Process a domain whitelist quadruple entry. // Get the index of the wildcard. val thirdWildcardIndex = thirdEntry.indexOf("*") // Split the entry into components. val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) // Create an entry string array. val domainQuadrupleEntry = arrayOf(domain, firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainQuadrupleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + // realThirdEntry + " , " + fourthEntry + " - " + originalBlocklistEntry); } else { // Process a domain whitelist triple entry. // Create an entry string array. val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainTripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + // thirdEntry + " - " + originalBlocklistEntry); } } else { // Process a domain whitelist double entry. // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } } else { // Process a domain whitelist single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } } } // Ignore all other filter entries. } else if (blocklistEntry.endsWith("|")) { // Final whitelist entries. // Remove the final `|` from the entry. val entry = blocklistEntry.substring(0, blocklistEntry.length - 1) if (entry.contains("*")) { // Process a final whitelist double entry // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. finalWhitelist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process a final whitelist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the whitelist. finalWhitelist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final whitelist added: " + entry + " - " + originalBlocklistEntry); } } else { // Main whitelist entries. if (blocklistEntry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = blocklistEntry.indexOf("*") // Split the entry into components. val firstEntry = blocklistEntry.substring(0, wildcardIndex) val secondEntry = blocklistEntry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a main whitelist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the whitelist. mainWhitelist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); } else { // Process a main whitelist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. mainWhitelist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a main whitelist single entry. // Create an entry string array. val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) // Add the entry to the whitelist. mainWhitelist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + blocklistEntry + " - " + originalBlocklistEntry); } } } else if (blocklistEntry.endsWith("|")) { // Final blacklist entries. // Strip out the final "|" var entry = blocklistEntry.substring(0, blocklistEntry.length - 1) // Strip out any initial `||`. They are redundant in this case because the blocklist entry is being matched against the end of the URL. if (entry.startsWith("||")) { entry = entry.substring(2) } if (entry.contains("*")) { // Process a final blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process a final blacklist single entry. // create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + " - " + originalBlocklistEntry); } } else if (blocklistEntry.contains("$")) { // Entries with filter options. // Strip out any initial `||`. These will be treated like any other entry. if (blocklistEntry.startsWith("||")) { blocklistEntry = blocklistEntry.substring(2) } if (blocklistEntry.contains("third-party")) { // Third-party entries. if (blocklistEntry.contains("~third-party")) { // Third-party filter whitelist entries. // Do not process these whitelist entries. They are designed to combine with block filters that Privacy Browser doesn't use, like `subdocument` and `xmlhttprequest`. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else if (blocklistEntry.contains("domain=")) { // Third-party domain entries. if (blocklistEntry.startsWith("|")) { // Third-party domain initial entries. // Strip the initial `|`. blocklistEntry = blocklistEntry.substring(1) // Parse the entry val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) var domains = filters.substring(filters.indexOf("domain=") + 7) if (entry == "http:" || entry == "https:" || entry == "http://" || entry == "https://") { // Ignore generic entries. // Do nothing. These entries will almost entirely disable the website. // Often the original entry blocks filter options like `$script`, which Privacy Browser does not differentiate. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else { // Third-party domain initial entries. // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } if (entry.contains("*")) { // Three are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a third-party domain initial blacklist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val tripleDomainEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyDomainInitialBlacklist.add(tripleDomainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + // " , " + thirdEntry + " - " + originalBlocklistEntry); } else { // Process a third-party domain initial blacklist double entry. // Create an entry string array. val doubleDomainEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyDomainInitialBlacklist.add(doubleDomainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + // " - " + originalBlocklistEntry); } } else { // Process a third-party domain initial blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyDomainInitialBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } } else if (blocklistEntry.contains("\\")) { // Process a third-party domain blacklist regular expression. // Parse the entry. At least one regular expression in this entry contains `$`, so the parser uses `/$`. val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("/$") + 1) val filters = blocklistEntry.substring(blocklistEntry.indexOf("/$") + 2) var domains = filters.substring(filters.indexOf("domain=") + 7) // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyDomainRegularExpressionBlacklist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain regular expression blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } while (domains.contains("|")) } else { // Third-party domain entries. // Parse the entry var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) var domains = filters.substring(filters.indexOf("domain=") + 7) // Strip any trailing "*" from the entry. if (entry.endsWith("*")) { entry = entry.substring(0, entry.length - 1) } // Track if any third-party whitelist filters are applied. var whitelistDomain = false // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // The is only one domain in the list. domain = domains } // Differentiate between blocklist domains and whitelist domains. if (domain.startsWith("~")) { // Whitelist third-party domain entry. // Strip the initial `~`. domain = domain.substring(1) // Set the whitelist domain flag. whitelistDomain = true if (entry.contains("*")) { // Process a third-party domain whitelist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyDomainWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } else { // Process a third-party domain whitelist single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the whitelist. thirdPartyDomainWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } else { // Third-party domain blacklist entries. if (entry.contains("*")) { // Process a third-party domain blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist thirdPartyDomainBlacklist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } else { // Process a third-party domain blacklist single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyDomainBlacklist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party domain blocklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } } while (domains.contains("|")) // Add a third-party blacklist entry if a whitelist domain was processed. if (whitelistDomain) { if (entry.contains("*")) { // Process a third-party blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process a third-party blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add an entry to the blacklist. thirdPartyBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + entry + " - " + originalBlocklistEntry); } } } } else if (blocklistEntry.startsWith("|")) { // Third-party initial blacklist entries. // Strip the initial `|`. blocklistEntry = blocklistEntry.substring(1) // Get the entry. val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) if (entry.contains("*")) { // Process a third-party initial blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val thirdPartyDoubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyInitialBlacklist.add(thirdPartyDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party initial blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process a third-party initial blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyInitialBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party initial blacklist added: " + entry + " - " + originalBlocklistEntry); } } else if (blocklistEntry.contains("\\")) { // Process a regular expression blacklist entry. // Prepare a string to hold the entry. // Get the entry. val entry: String = if (blocklistEntry.contains("$/$")) { // The first `$` is part of the regular expression. blocklistEntry.substring(0, blocklistEntry.indexOf("$/$") + 2) } else { // The only `$` indicates the filter options. blocklistEntry.substring(0, blocklistEntry.indexOf("$")) } // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyRegularExpressionBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party regular expression blacklist added: " + entry + " - " + originalBlocklistEntry); } else if (blocklistEntry.contains("*")) { // Third-party and regular expression blacklist entries. // Get the entry. var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) if (entry.endsWith("*")) { // Process a third-party blacklist single entry. // Strip the final `*`. entry = entry.substring(0, entry.length - 1) // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third party blacklist added: " + entry + " - " + originalBlocklistEntry); } else { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // There are three or more entries. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) if (thirdEntry.contains("*")) { // Process a third-party blacklist quadruple entry. // Get the index of the wildcard. val thirdWildcardIndex = thirdEntry.indexOf("*") // Split the entry into components. val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) // Create an entry string array. val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyBlacklist.add(quadrupleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + // fourthEntry + " - " + originalBlocklistEntry); } else { // Process a third-party blacklist triple entry. // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyBlacklist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + // originalBlocklistEntry); } } else { // Process a third-party blacklist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } } else { // Process a third party blacklist single entry. // Get the entry. val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. thirdPartyBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " third party blacklist added: " + entry + " - " + originalBlocklistEntry); } } else if (blocklistEntry.substring(blocklistEntry.indexOf("$")).contains("domain=")) { // Domain entries. if (blocklistEntry.contains("~")) { // Domain whitelist entries. // Separate the filters. var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) var domains = filters.substring(filters.indexOf("domain=") + 7) // Strip any final `*` from the entry. They are redundant. if (entry.endsWith("*")) { entry = entry.substring(0, entry.length - 1) } // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } // Strip the initial `~`. domain = domain.substring(1) if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a domain whitelist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainTripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + // " - " + originalBlocklistEntry); } else { // Process a domain whitelist double entry. // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a domain whitelist single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the whitelist. domainWhitelist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } else { // Domain blacklist entries. // Separate the filters. val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1) var domains = filters.substring(filters.indexOf("domain=") + 7) // Only process the item if the entry is not null. For example, some lines begin with `$websocket`, which create a null entry. if (entry != "") { // Process each domain. do { // Create a string to keep track of the current domain. var domain: String if (domains.contains("|")) { // There is more than one domain in the list. // Get the first domain from the list. domain = domains.substring(0, domains.indexOf("|")) // Remove the first domain from the list. domains = domains.substring(domains.indexOf("|") + 1) } else { // There is only one domain in the list. domain = domains } if (entry.startsWith("|")) { // Domain initial blacklist entries. // Remove the initial `|`; val entryBase = entry.substring(1) if (entryBase == "http://" || entryBase == "https://") { // Do nothing. These entries will entirely block the website. // Often the original entry blocks `$script` but Privacy Browser does not currently differentiate between scripts and other entries. //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry); } else { // Process a domain initial blacklist entry // Create an entry string array. val domainEntry = arrayOf(domain, entryBase, originalBlocklistEntry) // Add the entry to the blacklist. domainInitialBlacklist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain initial blacklist added: " + domain + " , " + entryBase + " - " + originalBlocklistEntry); } } else if (entry.endsWith("|")) { // Domain final blacklist entries. // Remove the final `|`. val entryBase = entry.substring(0, entry.length - 1) if (entryBase.contains("*")) { // Process a domain final blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entryBase.substring(0, wildcardIndex) val secondEntry = entryBase.substring(wildcardIndex + 1) // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. domainFinalBlacklist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain final blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } else { // Process a domain final blacklist single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entryBase, originalBlocklistEntry) // Add the entry to the blacklist. domainFinalBlacklist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain final blacklist added: " + domain + " , " + entryBase + " - " + originalBlocklistEntry); } } else if (entry.contains("\\")) { // Process a domain regular expression blacklist entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the blacklist. domainRegularExpressionBlacklist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain regular expression blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } else if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a domain blacklist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. domainBlacklist.add(domainTripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + // " - " + originalBlocklistEntry); } else { // Process a domain blacklist double entry. // Create an entry string array. val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. domainBlacklist.add(domainDoubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + " - " + // originalBlocklistEntry); } } else { // Process a domain blacklist single entry. // Create an entry string array. val domainEntry = arrayOf(domain, entry, originalBlocklistEntry) // Add the entry to the blacklist. domainBlacklist.add(domainEntry) //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + entry + " - " + originalBlocklistEntry); } } while (domains.contains("|")) } } } else if (blocklistEntry.contains("~")) { // Whitelist entries. Privacy Browser does not differentiate against these filter options, so they are just generally whitelisted. // Remove the filter options. blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) // Strip any trailing `*`. if (blocklistEntry.endsWith("*")) { blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1) } if (blocklistEntry.contains("*")) { // Process a whitelist double entry. // Get the index of the wildcard. val wildcardIndex = blocklistEntry.indexOf("*") // Split the entry into components. val firstEntry = blocklistEntry.substring(0, wildcardIndex) val secondEntry = blocklistEntry.substring(wildcardIndex + 1) // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the whitelist. mainWhitelist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process a whitelist single entry. // Create an entry string array. val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) // Add the entry to the whitelist. mainWhitelist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + blocklistEntry + " - + " + originalBlocklistEntry); } } else if (blocklistEntry.contains("\\")) { // Process a regular expression blacklist entry. // Remove the filter options. blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) // Create an entry string array. val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) // Add the entry to the blacklist. regularExpressionBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " regular expression blacklist added: " + blocklistEntry + " - " + originalBlocklistEntry); } else { // Blacklist entries. // Remove the filter options. if (!blocklistEntry.contains("\$file")) { // EasyPrivacy contains an entry with `$file` that does not have filter options. blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$")) } // Strip any trailing `*`. These are redundant. if (blocklistEntry.endsWith("*")) { blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1) } if (blocklistEntry.startsWith("|")) { // Initial blacklist entries. // Strip the initial `|`. val entry = blocklistEntry.substring(1) if (entry.contains("*")) { // Process an initial blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. initialBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process an initial blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. initialBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + entry + " - " + originalBlocklistEntry); } } else if (blocklistEntry.endsWith("|")) { // Final blacklist entries. // Ignore entries with `object` filters. They can block entire websites and don't have any meaning in the context of Privacy Browser. if (!originalBlocklistEntry.contains("\$object")) { // Strip the final `|`. val entry = blocklistEntry.substring(0, blocklistEntry.length - 1) if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a final blacklist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + // originalBlocklistEntry); } else { // Process a final blacklist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a final blacklist single entry. // Create an entry sting array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + " - " + originalBlocklistEntry); } } } else if (blocklistEntry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = blocklistEntry.indexOf("*") // Split the entry into components. val firstEntry = blocklistEntry.substring(0, wildcardIndex) val secondEntry = blocklistEntry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a main blacklist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); } else { // Process a main blacklist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a main blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + blocklistEntry + " - " + originalBlocklistEntry); } } } else { // Main blacklist entries // Strip out any initial `||`. These will be treated like any other entry. if (blocklistEntry.startsWith("||")) { blocklistEntry = blocklistEntry.substring(2) } // Strip out any initial `*`. if (blocklistEntry.startsWith("*")) { blocklistEntry = blocklistEntry.substring(1) } // Strip out any trailing `*`. if (blocklistEntry.endsWith("*")) { blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1) } if (blocklistEntry.startsWith("|")) { // Initial blacklist entries. // Strip the initial `|`. val entry = blocklistEntry.substring(1) if (entry.contains("*")) { // Process an initial blacklist double entry. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. initialBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } else { // Process an initial blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. initialBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + entry + " - " + originalBlocklistEntry); } } else if (blocklistEntry.endsWith("|")) { // Final blacklist entries. // Strip the final `|`. val entry = blocklistEntry.substring(0, blocklistEntry.length - 1) if (entry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = entry.indexOf("*") // Split the entry into components. val firstEntry = entry.substring(0, wildcardIndex) val secondEntry = entry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // Process a final blacklist triple entry. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); } else { // Process a final blacklist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a final blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(entry, originalBlocklistEntry) // Add the entry to the blacklist. finalBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + " - " + originalBlocklistEntry); } } else { // Main blacklist entries. if (blocklistEntry.contains("*")) { // There are two or more entries. // Get the index of the wildcard. val wildcardIndex = blocklistEntry.indexOf("*") // Split the entry into components. val firstEntry = blocklistEntry.substring(0, wildcardIndex) val secondEntry = blocklistEntry.substring(wildcardIndex + 1) if (secondEntry.contains("*")) { // There are three or more entries. // Get the index of the wildcard. val secondWildcardIndex = secondEntry.indexOf("*") // Split the entry into components. val realSecondEntry = secondEntry.substring(0, secondWildcardIndex) val thirdEntry = secondEntry.substring(secondWildcardIndex + 1) if (thirdEntry.contains("*")) { // There are four or more entries. // Get the index of the wildcard. val thirdWildcardIndex = thirdEntry.indexOf("*") // Split the entry into components. val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex) val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1) if (fourthEntry.contains("*")) { // Process a main blacklist quintuple entry. // Get the index of the wildcard. val fourthWildcardIndex = fourthEntry.indexOf("*") // Split the entry into components. val realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex) val fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1) // Create an entry string array. val quintupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(quintupleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + realFourthEntry + " , " + // fifthEntry + " - " + originalBlocklistEntry); } else { // Process a main blacklist quadruple entry. // Create an entry string array. val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(quadrupleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + fourthEntry + " - " + // originalBlocklistEntry); } } else { // Process a main blacklist triple entry. // Create an entry string array. val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(tripleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + " - " + originalBlocklistEntry); } } else { // Process a main blacklist double entry. // Create an entry string array. val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(doubleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + secondEntry + " - " + originalBlocklistEntry); } } else { // Process a main blacklist single entry. // Create an entry string array. val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry) // Add the entry to the blacklist. mainBlacklist.add(singleEntry) //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + blocklistEntry + " - " + originalBlocklistEntry); } } } } // Close `bufferedReader`. bufferedReader.close() } catch (e: IOException) { // The asset exists, so the `IOException` will never be thrown. } // Initialize the combined list. val combinedLists = ArrayList>>() // Add the headers (0). combinedLists.add(headers) // 0. // Add the whitelists (1-8). combinedLists.add(mainWhitelist) // 1. combinedLists.add(finalWhitelist) // 2. combinedLists.add(domainWhitelist) // 3. combinedLists.add(domainInitialWhitelist) // 4. combinedLists.add(domainFinalWhitelist) // 5. combinedLists.add(thirdPartyWhitelist) // 6. combinedLists.add(thirdPartyDomainWhitelist) // 7. combinedLists.add(thirdPartyDomainInitialWhitelist) // 8. // Add the blacklists (9-22). combinedLists.add(mainBlacklist) // 9. combinedLists.add(initialBlacklist) // 10. combinedLists.add(finalBlacklist) // 11. combinedLists.add(domainBlacklist) // 12. combinedLists.add(domainInitialBlacklist) // 13. combinedLists.add(domainFinalBlacklist) // 14. combinedLists.add(domainRegularExpressionBlacklist) // 15. combinedLists.add(thirdPartyBlacklist) // 16. combinedLists.add(thirdPartyInitialBlacklist) // 17. combinedLists.add(thirdPartyDomainBlacklist) // 18. combinedLists.add(thirdPartyDomainInitialBlacklist) // 19. combinedLists.add(thirdPartyRegularExpressionBlacklist) // 20. combinedLists.add(thirdPartyDomainRegularExpressionBlacklist) // 21. combinedLists.add(regularExpressionBlacklist) // 22. // Return the combined lists. return combinedLists } fun checkBlocklist(currentDomain: String?, resourceUrl: String, isThirdPartyRequest: Boolean, blocklist: ArrayList>>): Array { // Get the blocklist name. val blocklistName = blocklist[0][1][0] // Process the whitelists. // Main whitelist. for (whitelistEntry in blocklist[MAIN_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 2 -> if (resourceUrl.contains(whitelistEntry[0])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, whitelistEntry[0], whitelistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2] ) } // There are three entries. 4 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } } } // Final whitelist. for (whitelistEntry in blocklist[FINAL_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 2 -> if (resourceUrl.contains(whitelistEntry[0])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, FINAL_WHITELIST, whitelistEntry[0], whitelistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) } } } // Only check the domain lists if the current domain is not null (like `about:blank`). if (currentDomain != null) { // Domain whitelist. for (whitelistEntry in blocklist[DOMAIN_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) } // There are two entries. 4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } // There are three entries. 5 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", whitelistEntry[4]) } // There are four entries. 6 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) && resourceUrl.contains(whitelistEntry[4])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}\n${whitelistEntry[4]}", whitelistEntry[5]) } } } // Domain initial whitelist. for (whitelistEntry in blocklist[DOMAIN_INITIAL_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}".trimIndent(), whitelistEntry[2]) } // There are two entries. 4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } // There are three entries. 5 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.startsWith(whitelistEntry[3])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", whitelistEntry[4]) } } } // Domain final whitelist. for (whitelistEntry in blocklist[DOMAIN_FINAL_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.endsWith(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) } // There are two entries. 4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.endsWith(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } } } } // Only check the third-party whitelists if this is a third-party request. if (isThirdPartyRequest) { // Third-party whitelist. for (whitelistEntry in blocklist[THIRD_PARTY_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 2 -> if (resourceUrl.contains(whitelistEntry[0])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, whitelistEntry[0], whitelistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]) } // There are three entries. 4 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } // There are four entries. 5 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", whitelistEntry[4]) } // There are five entries. 6 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) && resourceUrl.contains(whitelistEntry[4])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}\n${whitelistEntry[4]}", whitelistEntry[5]) } } } // Third-party domain whitelist. for (whitelistEntry in blocklist[THIRD_PARTY_DOMAIN_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 3 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n", whitelistEntry[2]) } // There are two entries. 4 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } } } // Third-party domain initial whitelist. for (whitelistEntry in blocklist[THIRD_PARTY_DOMAIN_INITIAL_WHITELIST.toInt()]) { when (whitelistEntry.size) { // There is one entry. 3 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n", whitelistEntry[2]) } // There are two entries. 4 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) { // Return a whitelist match request allowed. return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3]) } } } } // Process the blacklists. // Main blacklist. for (blacklistEntry in blocklist[MAIN_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 2 -> if (resourceUrl.contains(blacklistEntry[0])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } // There are three entries. 4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } // There are four entries. 5 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) } // There are five entries. 6 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3]) && resourceUrl.contains(blacklistEntry[4])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}\n${blacklistEntry[4]}", blacklistEntry[5]) } } } // Initial blacklist. for (blacklistEntry in blocklist[INITIAL_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 2 -> if (resourceUrl.startsWith(blacklistEntry[0])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } // There are two entries 3 -> if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } } } // Final blacklist. for (blacklistEntry in blocklist[FINAL_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 2 -> if (resourceUrl.endsWith(blacklistEntry[0])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } // There are three entries. 4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } } } // Only check the domain lists if the current domain is not null (like `about:blank`). if (currentDomain != null) { // Domain blacklist. for (blacklistEntry in blocklist[DOMAIN_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 3 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } // There are two entries. 4 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } // There are three entries. 5 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) } } } // Domain initial blacklist. for (blacklistEntry in blocklist[DOMAIN_INITIAL_BLACKLIST.toInt()]) { // Store the entry in the resource request log. if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } } // Domain final blacklist. for (blacklistEntry in blocklist[DOMAIN_FINAL_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 3 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } // There are two entries. 4 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } } } // Domain regular expression blacklist. for (blacklistEntry in blocklist[DOMAIN_REGULAR_EXPRESSION_BLACKLIST.toInt()]) { if (currentDomain.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_REGULAR_EXPRESSION_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } } } // Only check the third-party blacklists if this is a third-party request. if (isThirdPartyRequest) { // Third-party blacklist. for (blacklistEntry in blocklist[THIRD_PARTY_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 2 -> if (resourceUrl.contains(blacklistEntry[0])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf( REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n", blacklistEntry[2]) } // There are three entries. 4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } // There are four entries. 5 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) } } } // Third-party initial blacklist. for (blacklistEntry in blocklist[THIRD_PARTY_INITIAL_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 2 -> if (resourceUrl.startsWith(blacklistEntry[0])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } // There are two entries. 3 -> if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } } } // Third-party domain blacklist. for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 3 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } // There are two entries. 4 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } } } // Third-party domain initial blacklist. for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST.toInt()]) { when (blacklistEntry.size) { // There is one entry. 3 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n", blacklistEntry[2]) } // There are two entries. 4 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3]) } // There are three entries. 5 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4]) } } } // Third-party regular expression blacklist. for (blacklistEntry in blocklist[THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST.toInt()]) { if (Pattern.matches(blacklistEntry[0], resourceUrl)) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } } // Third-party domain regular expression blacklist. for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST.toInt()]) { if (currentDomain!!.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2]) } } } // Regular expression blacklist. for (blacklistEntry in blocklist[REGULAR_EXPRESSION_BLACKLIST.toInt()]) { if (Pattern.matches(blacklistEntry[0], resourceUrl)) { // Return a blacklist match request blocked. return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1]) } } // Return a no match request default. return arrayOf(REQUEST_DEFAULT) } }