Refactor CleartextStorage libraries

egregius313 · egregius313 · commit aa7934161aac · 2023-03-29T22:33:08.000-04:00
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStorageAndroidDatabaseQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStorageAndroidDatabaseQuery.qll
@@ -29,16 +29,16 @@ class LocalDatabaseOpenMethodAccess extends Storable, Call {
   }
 
   override Expr getAnInput() {
-    exists(LocalDatabaseFlowConfig config, DataFlow::Node database |
+    exists(DataFlow::Node database |
       localDatabaseInput(database, result) and
-      config.hasFlow(DataFlow::exprNode(this), database)
+      LocalDatabaseFlow::flow(DataFlow::exprNode(this), database)
     )
   }
 
   override Expr getAStore() {
-    exists(LocalDatabaseFlowConfig config, DataFlow::Node database |
+    exists(DataFlow::Node database |
       localDatabaseStore(database, result) and
-      config.hasFlow(DataFlow::exprNode(this), database)
+      LocalDatabaseFlow::flow(DataFlow::exprNode(this), database)
     )
   }
 }
@@ -93,19 +93,17 @@ private predicate localDatabaseStore(DataFlow::Node database, MethodAccess store
   )
 }
 
-private class LocalDatabaseFlowConfig extends DataFlow::Configuration {
-  LocalDatabaseFlowConfig() { this = "LocalDatabaseFlowConfig" }
-
-  override predicate isSource(DataFlow::Node source) {
+private module LocalDatabaseFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node source) {
     source.asExpr() instanceof LocalDatabaseOpenMethodAccess
   }
 
-  override predicate isSink(DataFlow::Node sink) {
+  predicate isSink(DataFlow::Node sink) {
     localDatabaseInput(sink, _) or
     localDatabaseStore(sink, _)
   }
 
-  override predicate isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) {
+  predicate isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) {
     // Adds a step for tracking databases through field flow, that is, a database is opened and
     // assigned to a field, and then an input or store method is called on that field elsewhere.
     exists(Field f |
@@ -115,3 +113,5 @@ private class LocalDatabaseFlowConfig extends DataFlow::Configuration {
     )
   }
 }
+
+private module LocalDatabaseFlow = DataFlow::Global<LocalDatabaseFlowConfig>;
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStorageAndroidFilesystemQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStorageAndroidFilesystemQuery.qll
@@ -24,16 +24,16 @@ class LocalFileOpenCall extends Storable {
   }
 
   override Expr getAnInput() {
-    exists(FilesystemFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       filesystemInput(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      FilesystemFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 
   override Expr getAStore() {
-    exists(FilesystemFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       closesFile(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      FilesystemFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 }
@@ -79,17 +79,15 @@ private class CloseFileMethod extends Method {
   }
 }
 
-private class FilesystemFlowConfig extends DataFlow::Configuration {
-  FilesystemFlowConfig() { this = "FilesystemFlowConfig" }
+private module FilesystemFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) { src.asExpr() instanceof LocalFileOpenCall }
 
-  override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof LocalFileOpenCall }
-
-  override predicate isSink(DataFlow::Node sink) {
+  predicate isSink(DataFlow::Node sink) {
     filesystemInput(sink, _) or
     closesFile(sink, _)
   }
 
-  override predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
+  predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {
     // Add nested Writer constructors as extra data flow steps
     exists(ClassInstanceExpr cie |
       cie.getConstructedType().getAnAncestor().hasQualifiedName("java.io", "Writer") and
@@ -98,3 +96,5 @@ private class FilesystemFlowConfig extends DataFlow::Configuration {
     )
   }
 }
+
+private module FilesystemFlow = DataFlow::Global<FilesystemFlowConfig>;
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStorageClassQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStorageClassQuery.qll
@@ -14,8 +14,8 @@ private class ClassCleartextStorageSink extends CleartextStorageSink {
 abstract class ClassStore extends Storable, ClassInstanceExpr {
   /** Gets an input, for example `input` in `instance.password = input`. */
   override Expr getAnInput() {
-    exists(ClassStoreFlowConfig conf, DataFlow::Node instance |
-      conf.hasFlow(DataFlow::exprNode(this), instance) and
+    exists(DataFlow::Node instance |
+      ClassStoreFlow::flow(DataFlow::exprNode(this), instance) and
       result = getInstanceInput(instance, this.getConstructor().getDeclaringType())
     )
   }
@@ -40,9 +40,9 @@ private class Serializable extends ClassStore {
 
   /** Gets a store, for example `outputStream.writeObject(instance)`. */
   override Expr getAStore() {
-    exists(ClassStoreFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       serializableStore(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      ClassStoreFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 }
@@ -53,9 +53,9 @@ private class Marshallable extends ClassStore {
 
   /** Gets a store, for example `marshaller.marshal(instance)`. */
   override Expr getAStore() {
-    exists(ClassStoreFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       marshallableStore(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      ClassStoreFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 }
@@ -73,20 +73,20 @@ private Expr getInstanceInput(DataFlow::Node instance, RefType t) {
   )
 }
 
-private class ClassStoreFlowConfig extends DataFlow::Configuration {
-  ClassStoreFlowConfig() { this = "ClassStoreFlowConfig" }
+private module ClassStoreFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) { src.asExpr() instanceof ClassStore }
 
-  override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof ClassStore }
-
-  override predicate isSink(DataFlow::Node sink) {
+  predicate isSink(DataFlow::Node sink) {
     exists(getInstanceInput(sink, _)) or
     serializableStore(sink, _) or
     marshallableStore(sink, _)
   }
 
-  override int fieldFlowBranchLimit() { result = 1 }
+  int fieldFlowBranchLimit() { result = 1 }
 }
 
+private module ClassStoreFlow = DataFlow::Global<ClassStoreFlowConfig>;
+
 private predicate serializableStore(DataFlow::Node instance, Expr store) {
   exists(MethodAccess m |
     store = m and
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStorageCookieQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStorageCookieQuery.qll
@@ -20,9 +20,9 @@ class Cookie extends Storable, ClassInstanceExpr {
 
   /** Gets a store, for example `response.addCookie(cookie);`. */
   override Expr getAStore() {
-    exists(CookieToStoreFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       cookieStore(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      CookieToStoreFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 }
@@ -37,12 +37,12 @@ private predicate cookieStore(DataFlow::Node cookie, Expr store) {
   )
 }
 
-private class CookieToStoreFlowConfig extends DataFlow3::Configuration {
-  CookieToStoreFlowConfig() { this = "CookieToStoreFlowConfig" }
+private module CookieToStoreFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Cookie }
 
-  override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Cookie }
-
-  override predicate isSink(DataFlow::Node sink) { cookieStore(sink, _) }
+  predicate isSink(DataFlow::Node sink) { cookieStore(sink, _) }
 }
 
+private module CookieToStoreFlow = DataFlow::Global<CookieToStoreFlowConfig>;
+
 private Expr cookieInput(Cookie c) { result = c.getArgument(1) }
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStoragePropertiesQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStoragePropertiesQuery.qll
@@ -19,17 +19,17 @@ class Properties extends Storable, ClassInstanceExpr {
 
   /** Gets an input, for example `input` in `props.setProperty("password", input);`. */
   override Expr getAnInput() {
-    exists(PropertiesFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       propertiesInput(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      PropertiesFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 
   /** Gets a store, for example `props.store(outputStream, "...")`. */
   override Expr getAStore() {
-    exists(PropertiesFlowConfig conf, DataFlow::Node n |
+    exists(DataFlow::Node n |
       propertiesStore(n, result) and
-      conf.hasFlow(DataFlow::exprNode(this), n)
+      PropertiesFlow::flow(DataFlow::exprNode(this), n)
     )
   }
 }
@@ -50,13 +50,13 @@ private predicate propertiesStore(DataFlow::Node prop, Expr store) {
   )
 }
 
-private class PropertiesFlowConfig extends DataFlow::Configuration {
-  PropertiesFlowConfig() { this = "PropertiesFlowConfig" }
+private module PropertiesFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Properties }
 
-  override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Properties }
-
-  override predicate isSink(DataFlow::Node sink) {
+  predicate isSink(DataFlow::Node sink) {
     propertiesInput(sink, _) or
     propertiesStore(sink, _)
   }
 }
+
+private module PropertiesFlow = DataFlow::Global<PropertiesFlowConfig>;
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStorageQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStorageQuery.qll
@@ -21,9 +21,7 @@ class CleartextStorageAdditionalTaintStep extends Unit {
 class SensitiveSource extends Expr instanceof SensitiveExpr {
   /** Holds if this source flows to the `sink`. */
   predicate flowsTo(Expr sink) {
-    exists(SensitiveSourceFlowConfig conf |
-      conf.hasFlow(DataFlow::exprNode(this), DataFlow::exprNode(sink))
-    )
+    SensitiveSourceFlow::flow(DataFlow::exprNode(this), DataFlow::exprNode(sink))
   }
 }
 
@@ -40,27 +38,25 @@ abstract class Storable extends Call {
   abstract Expr getAStore();
 }
 
-private class SensitiveSourceFlowConfig extends TaintTracking2::Configuration {
-  SensitiveSourceFlowConfig() { this = "SensitiveSourceFlowConfig" }
+private module SensitiveSourceFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) { src.asExpr() instanceof SensitiveExpr }
 
-  override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof SensitiveExpr }
+  predicate isSink(DataFlow::Node sink) { sink instanceof CleartextStorageSink }
 
-  override predicate isSink(DataFlow::Node sink) { sink instanceof CleartextStorageSink }
+  predicate isBarrier(DataFlow::Node sanitizer) { sanitizer instanceof CleartextStorageSanitizer }
 
-  override predicate isSanitizer(DataFlow::Node sanitizer) {
-    sanitizer instanceof CleartextStorageSanitizer
-  }
-
-  override predicate isAdditionalTaintStep(DataFlow::Node n1, DataFlow::Node n2) {
+  predicate isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) {
     any(CleartextStorageAdditionalTaintStep c).step(n1, n2)
   }
 }
 
+private module SensitiveSourceFlow = TaintTracking::Global<SensitiveSourceFlowConfig>;
+
 private class DefaultCleartextStorageSanitizer extends CleartextStorageSanitizer {
   DefaultCleartextStorageSanitizer() {
     this.getType() instanceof NumericType or
     this.getType() instanceof BooleanType or
-    exists(EncryptedValueFlowConfig conf | conf.hasFlow(_, this))
+    EncryptedValueFlow::flow(_, this)
   }
 }
 
@@ -76,12 +72,10 @@ private class EncryptedSensitiveMethodAccess extends MethodAccess {
 }
 
 /** Flow configuration for encryption methods flowing to inputs of persistent storage. */
-private class EncryptedValueFlowConfig extends DataFlow4::Configuration {
-  EncryptedValueFlowConfig() { this = "EncryptedValueFlowConfig" }
+private module EncryptedValueFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) { src.asExpr() instanceof EncryptedSensitiveMethodAccess }
 
-  override predicate isSource(DataFlow::Node src) {
-    src.asExpr() instanceof EncryptedSensitiveMethodAccess
-  }
-
-  override predicate isSink(DataFlow::Node sink) { sink.asExpr() instanceof SensitiveExpr }
+  predicate isSink(DataFlow::Node sink) { sink.asExpr() instanceof SensitiveExpr }
 }
+
+private module EncryptedValueFlow = DataFlow::Global<EncryptedValueFlowConfig>;
diff --git a/java/ql/lib/semmle/code/java/security/CleartextStorageSharedPrefsQuery.qll b/java/ql/lib/semmle/code/java/security/CleartextStorageSharedPrefsQuery.qll
@@ -28,17 +28,17 @@ class SharedPreferencesEditorMethodAccess extends Storable, MethodAccess {
 
   /** Gets an input, for example `password` in `editor.putString("password", password);`. */
   override Expr getAnInput() {
-    exists(SharedPreferencesFlowConfig conf, DataFlow::Node editor |
+    exists(DataFlow::Node editor |
       sharedPreferencesInput(editor, result) and
-      conf.hasFlow(DataFlow::exprNode(this), editor)
+      SharedPreferencesFlow::flow(DataFlow::exprNode(this), editor)
     )
   }
 
   /** Gets a store, for example `editor.commit();`. */
   override Expr getAStore() {
-    exists(SharedPreferencesFlowConfig conf, DataFlow::Node editor |
+    exists(DataFlow::Node editor |
       sharedPreferencesStore(editor, result) and
-      conf.hasFlow(DataFlow::exprNode(this), editor)
+      SharedPreferencesFlow::flow(DataFlow::exprNode(this), editor)
     )
   }
 }
@@ -65,15 +65,15 @@ private predicate sharedPreferencesStore(DataFlow::Node editor, MethodAccess m)
 }
 
 /** Flow from `SharedPreferences.Editor` to either a setter or a store method. */
-private class SharedPreferencesFlowConfig extends DataFlow::Configuration {
-  SharedPreferencesFlowConfig() { this = "SharedPreferencesFlowConfig" }
-
-  override predicate isSource(DataFlow::Node src) {
+private module SharedPreferencesFlowConfig implements DataFlow::ConfigSig {
+  predicate isSource(DataFlow::Node src) {
     src.asExpr() instanceof SharedPreferencesEditorMethodAccess
   }
 
-  override predicate isSink(DataFlow::Node sink) {
+  predicate isSink(DataFlow::Node sink) {
     sharedPreferencesInput(sink, _) or
     sharedPreferencesStore(sink, _)
   }
 }
+
+private module SharedPreferencesFlow = DataFlow::Global<SharedPreferencesFlowConfig>;

Original file line number	Diff line number	Diff line change
`@@ -29,16 +29,16 @@ class LocalDatabaseOpenMethodAccess extends Storable, Call {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`override Expr getAnInput() {`
`32`		`- exists(LocalDatabaseFlowConfig config, DataFlow::Node database \|`
	`32`	`+ exists(DataFlow::Node database \|`
`33`	`33`	`localDatabaseInput(database, result) and`
`34`		`- config.hasFlow(DataFlow::exprNode(this), database)`
	`34`	`+ LocalDatabaseFlow::flow(DataFlow::exprNode(this), database)`
`35`	`35`	`)`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`override Expr getAStore() {`
`39`		`- exists(LocalDatabaseFlowConfig config, DataFlow::Node database \|`
	`39`	`+ exists(DataFlow::Node database \|`
`40`	`40`	`localDatabaseStore(database, result) and`
`41`		`- config.hasFlow(DataFlow::exprNode(this), database)`
	`41`	`+ LocalDatabaseFlow::flow(DataFlow::exprNode(this), database)`
`42`	`42`	`)`
`43`	`43`	`}`
`44`	`44`	`}`
`@@ -93,19 +93,17 @@ private predicate localDatabaseStore(DataFlow::Node database, MethodAccess store`
`93`	`93`	`)`
`94`	`94`	`}`
`95`	`95`
`96`		`-private class LocalDatabaseFlowConfig extends DataFlow::Configuration {`
`97`		`- LocalDatabaseFlowConfig() { this = "LocalDatabaseFlowConfig" }`
`98`		`-`
`99`		`- override predicate isSource(DataFlow::Node source) {`
	`96`	`+private module LocalDatabaseFlowConfig implements DataFlow::ConfigSig {`
	`97`	`+ predicate isSource(DataFlow::Node source) {`
`100`	`98`	`source.asExpr() instanceof LocalDatabaseOpenMethodAccess`
`101`	`99`	`}`
`102`	`100`
`103`		`- override predicate isSink(DataFlow::Node sink) {`
	`101`	`+ predicate isSink(DataFlow::Node sink) {`
`104`	`102`	`localDatabaseInput(sink, _) or`
`105`	`103`	`localDatabaseStore(sink, _)`
`106`	`104`	`}`
`107`	`105`
`108`		`- override predicate isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) {`
	`106`	`+ predicate isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) {`
`109`	`107`	`// Adds a step for tracking databases through field flow, that is, a database is opened and`
`110`	`108`	`// assigned to a field, and then an input or store method is called on that field elsewhere.`
`111`	`109`	`exists(Field f \|`
`@@ -115,3 +113,5 @@ private class LocalDatabaseFlowConfig extends DataFlow::Configuration {`
`115`	`113`	`)`
`116`	`114`	`}`
`117`	`115`	`}`
	`116`	`+`
	`117`	`+private module LocalDatabaseFlow = DataFlow::Global<LocalDatabaseFlowConfig>;`
Original file line number	Diff line number	Diff line change
`@@ -24,16 +24,16 @@ class LocalFileOpenCall extends Storable {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`override Expr getAnInput() {`
`27`		`- exists(FilesystemFlowConfig conf, DataFlow::Node n \|`
	`27`	`+ exists(DataFlow::Node n \|`
`28`	`28`	`filesystemInput(n, result) and`
`29`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`29`	`+ FilesystemFlow::flow(DataFlow::exprNode(this), n)`
`30`	`30`	`)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`override Expr getAStore() {`
`34`		`- exists(FilesystemFlowConfig conf, DataFlow::Node n \|`
	`34`	`+ exists(DataFlow::Node n \|`
`35`	`35`	`closesFile(n, result) and`
`36`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`36`	`+ FilesystemFlow::flow(DataFlow::exprNode(this), n)`
`37`	`37`	`)`
`38`	`38`	`}`
`39`	`39`	`}`
`@@ -79,17 +79,15 @@ private class CloseFileMethod extends Method {`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`		`-private class FilesystemFlowConfig extends DataFlow::Configuration {`
`83`		`- FilesystemFlowConfig() { this = "FilesystemFlowConfig" }`
	`82`	`+private module FilesystemFlowConfig implements DataFlow::ConfigSig {`
	`83`	`+ predicate isSource(DataFlow::Node src) { src.asExpr() instanceof LocalFileOpenCall }`
`84`	`84`
`85`		`- override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof LocalFileOpenCall }`
`86`		`-`
`87`		`- override predicate isSink(DataFlow::Node sink) {`
	`85`	`+ predicate isSink(DataFlow::Node sink) {`
`88`	`86`	`filesystemInput(sink, _) or`
`89`	`87`	`closesFile(sink, _)`
`90`	`88`	`}`
`91`	`89`
`92`		`- override predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {`
	`90`	`+ predicate isAdditionalFlowStep(DataFlow::Node node1, DataFlow::Node node2) {`
`93`	`91`	`// Add nested Writer constructors as extra data flow steps`
`94`	`92`	`exists(ClassInstanceExpr cie \|`
`95`	`93`	`cie.getConstructedType().getAnAncestor().hasQualifiedName("java.io", "Writer") and`
`@@ -98,3 +96,5 @@ private class FilesystemFlowConfig extends DataFlow::Configuration {`
`98`	`96`	`)`
`99`	`97`	`}`
`100`	`98`	`}`
	`99`	`+`
	`100`	`+private module FilesystemFlow = DataFlow::Global<FilesystemFlowConfig>;`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ private class ClassCleartextStorageSink extends CleartextStorageSink {`
`14`	`14`	`abstract class ClassStore extends Storable, ClassInstanceExpr {`
`15`	`15`	/** Gets an input, for example `input` in `instance.password = input`. */
`16`	`16`	`override Expr getAnInput() {`
`17`		`- exists(ClassStoreFlowConfig conf, DataFlow::Node instance \|`
`18`		`- conf.hasFlow(DataFlow::exprNode(this), instance) and`
	`17`	`+ exists(DataFlow::Node instance \|`
	`18`	`+ ClassStoreFlow::flow(DataFlow::exprNode(this), instance) and`
`19`	`19`	`result = getInstanceInput(instance, this.getConstructor().getDeclaringType())`
`20`	`20`	`)`
`21`	`21`	`}`
`@@ -40,9 +40,9 @@ private class Serializable extends ClassStore {`
`40`	`40`
`41`	`41`	/** Gets a store, for example `outputStream.writeObject(instance)`. */
`42`	`42`	`override Expr getAStore() {`
`43`		`- exists(ClassStoreFlowConfig conf, DataFlow::Node n \|`
	`43`	`+ exists(DataFlow::Node n \|`
`44`	`44`	`serializableStore(n, result) and`
`45`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`45`	`+ ClassStoreFlow::flow(DataFlow::exprNode(this), n)`
`46`	`46`	`)`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -53,9 +53,9 @@ private class Marshallable extends ClassStore {`
`53`	`53`
`54`	`54`	/** Gets a store, for example `marshaller.marshal(instance)`. */
`55`	`55`	`override Expr getAStore() {`
`56`		`- exists(ClassStoreFlowConfig conf, DataFlow::Node n \|`
	`56`	`+ exists(DataFlow::Node n \|`
`57`	`57`	`marshallableStore(n, result) and`
`58`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`58`	`+ ClassStoreFlow::flow(DataFlow::exprNode(this), n)`
`59`	`59`	`)`
`60`	`60`	`}`
`61`	`61`	`}`
`@@ -73,20 +73,20 @@ private Expr getInstanceInput(DataFlow::Node instance, RefType t) {`
`73`	`73`	`)`
`74`	`74`	`}`
`75`	`75`
`76`		`-private class ClassStoreFlowConfig extends DataFlow::Configuration {`
`77`		`- ClassStoreFlowConfig() { this = "ClassStoreFlowConfig" }`
	`76`	`+private module ClassStoreFlowConfig implements DataFlow::ConfigSig {`
	`77`	`+ predicate isSource(DataFlow::Node src) { src.asExpr() instanceof ClassStore }`
`78`	`78`
`79`		`- override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof ClassStore }`
`80`		`-`
`81`		`- override predicate isSink(DataFlow::Node sink) {`
	`79`	`+ predicate isSink(DataFlow::Node sink) {`
`82`	`80`	`exists(getInstanceInput(sink, _)) or`
`83`	`81`	`serializableStore(sink, _) or`
`84`	`82`	`marshallableStore(sink, _)`
`85`	`83`	`}`
`86`	`84`
`87`		`- override int fieldFlowBranchLimit() { result = 1 }`
	`85`	`+ int fieldFlowBranchLimit() { result = 1 }`
`88`	`86`	`}`
`89`	`87`
	`88`	`+private module ClassStoreFlow = DataFlow::Global<ClassStoreFlowConfig>;`
	`89`	`+`
`90`	`90`	`private predicate serializableStore(DataFlow::Node instance, Expr store) {`
`91`	`91`	`exists(MethodAccess m \|`
`92`	`92`	`store = m and`
Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,9 @@ class Cookie extends Storable, ClassInstanceExpr {`
`20`	`20`
`21`	`21`	/** Gets a store, for example `response.addCookie(cookie);`. */
`22`	`22`	`override Expr getAStore() {`
`23`		`- exists(CookieToStoreFlowConfig conf, DataFlow::Node n \|`
	`23`	`+ exists(DataFlow::Node n \|`
`24`	`24`	`cookieStore(n, result) and`
`25`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`25`	`+ CookieToStoreFlow::flow(DataFlow::exprNode(this), n)`
`26`	`26`	`)`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -37,12 +37,12 @@ private predicate cookieStore(DataFlow::Node cookie, Expr store) {`
`37`	`37`	`)`
`38`	`38`	`}`
`39`	`39`
`40`		`-private class CookieToStoreFlowConfig extends DataFlow3::Configuration {`
`41`		`- CookieToStoreFlowConfig() { this = "CookieToStoreFlowConfig" }`
	`40`	`+private module CookieToStoreFlowConfig implements DataFlow::ConfigSig {`
	`41`	`+ predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Cookie }`
`42`	`42`
`43`		`- override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Cookie }`
`44`		`-`
`45`		`- override predicate isSink(DataFlow::Node sink) { cookieStore(sink, _) }`
	`43`	`+ predicate isSink(DataFlow::Node sink) { cookieStore(sink, _) }`
`46`	`44`	`}`
`47`	`45`
	`46`	`+private module CookieToStoreFlow = DataFlow::Global<CookieToStoreFlowConfig>;`
	`47`	`+`
`48`	`48`	`private Expr cookieInput(Cookie c) { result = c.getArgument(1) }`
Original file line number	Diff line number	Diff line change
`@@ -19,17 +19,17 @@ class Properties extends Storable, ClassInstanceExpr {`
`19`	`19`
`20`	`20`	/** Gets an input, for example `input` in `props.setProperty("password", input);`. */
`21`	`21`	`override Expr getAnInput() {`
`22`		`- exists(PropertiesFlowConfig conf, DataFlow::Node n \|`
	`22`	`+ exists(DataFlow::Node n \|`
`23`	`23`	`propertiesInput(n, result) and`
`24`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`24`	`+ PropertiesFlow::flow(DataFlow::exprNode(this), n)`
`25`	`25`	`)`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	/** Gets a store, for example `props.store(outputStream, "...")`. */
`29`	`29`	`override Expr getAStore() {`
`30`		`- exists(PropertiesFlowConfig conf, DataFlow::Node n \|`
	`30`	`+ exists(DataFlow::Node n \|`
`31`	`31`	`propertiesStore(n, result) and`
`32`		`- conf.hasFlow(DataFlow::exprNode(this), n)`
	`32`	`+ PropertiesFlow::flow(DataFlow::exprNode(this), n)`
`33`	`33`	`)`
`34`	`34`	`}`
`35`	`35`	`}`
`@@ -50,13 +50,13 @@ private predicate propertiesStore(DataFlow::Node prop, Expr store) {`
`50`	`50`	`)`
`51`	`51`	`}`
`52`	`52`
`53`		`-private class PropertiesFlowConfig extends DataFlow::Configuration {`
`54`		`- PropertiesFlowConfig() { this = "PropertiesFlowConfig" }`
	`53`	`+private module PropertiesFlowConfig implements DataFlow::ConfigSig {`
	`54`	`+ predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Properties }`
`55`	`55`
`56`		`- override predicate isSource(DataFlow::Node src) { src.asExpr() instanceof Properties }`
`57`		`-`
`58`		`- override predicate isSink(DataFlow::Node sink) {`
	`56`	`+ predicate isSink(DataFlow::Node sink) {`
`59`	`57`	`propertiesInput(sink, _) or`
`60`	`58`	`propertiesStore(sink, _)`
`61`	`59`	`}`
`62`	`60`	`}`
	`61`	`+`
	`62`	`+private module PropertiesFlow = DataFlow::Global<PropertiesFlowConfig>;`
Original file line number	Diff line number	Diff line change
`@@ -28,17 +28,17 @@ class SharedPreferencesEditorMethodAccess extends Storable, MethodAccess {`
`28`	`28`
`29`	`29`	/** Gets an input, for example `password` in `editor.putString("password", password);`. */
`30`	`30`	`override Expr getAnInput() {`
`31`		`- exists(SharedPreferencesFlowConfig conf, DataFlow::Node editor \|`
	`31`	`+ exists(DataFlow::Node editor \|`
`32`	`32`	`sharedPreferencesInput(editor, result) and`
`33`		`- conf.hasFlow(DataFlow::exprNode(this), editor)`
	`33`	`+ SharedPreferencesFlow::flow(DataFlow::exprNode(this), editor)`
`34`	`34`	`)`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	/** Gets a store, for example `editor.commit();`. */
`38`	`38`	`override Expr getAStore() {`
`39`		`- exists(SharedPreferencesFlowConfig conf, DataFlow::Node editor \|`
	`39`	`+ exists(DataFlow::Node editor \|`
`40`	`40`	`sharedPreferencesStore(editor, result) and`
`41`		`- conf.hasFlow(DataFlow::exprNode(this), editor)`
	`41`	`+ SharedPreferencesFlow::flow(DataFlow::exprNode(this), editor)`
`42`	`42`	`)`
`43`	`43`	`}`
`44`	`44`	`}`
`@@ -65,15 +65,15 @@ private predicate sharedPreferencesStore(DataFlow::Node editor, MethodAccess m)`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	/** Flow from `SharedPreferences.Editor` to either a setter or a store method. */
`68`		`-private class SharedPreferencesFlowConfig extends DataFlow::Configuration {`
`69`		`- SharedPreferencesFlowConfig() { this = "SharedPreferencesFlowConfig" }`
`70`		`-`
`71`		`- override predicate isSource(DataFlow::Node src) {`
	`68`	`+private module SharedPreferencesFlowConfig implements DataFlow::ConfigSig {`
	`69`	`+ predicate isSource(DataFlow::Node src) {`
`72`	`70`	`src.asExpr() instanceof SharedPreferencesEditorMethodAccess`
`73`	`71`	`}`
`74`	`72`
`75`		`- override predicate isSink(DataFlow::Node sink) {`
	`73`	`+ predicate isSink(DataFlow::Node sink) {`
`76`	`74`	`sharedPreferencesInput(sink, _) or`
`77`	`75`	`sharedPreferencesStore(sink, _)`
`78`	`76`	`}`
`79`	`77`	`}`
	`78`	`+`
	`79`	`+private module SharedPreferencesFlow = DataFlow::Global<SharedPreferencesFlowConfig>;`