JDBI Wie kann ich dynamisch eine WHERE-Klausel erstellen, während SQL Injection verhindert wird?

Question

Ich möchte eine JDBI-Abfrage dynamisch filtern.

Die Liste der Parameter wird von der Benutzeroberfläche über REST übergeben, z.

http://localhost/things?foo=bar&baz=taz 
http://localhost/things?foo=buz 

Welche (plump) gebaut (Jersey @Context UriInfo :: getQueryParameters -> String) so etwas wie folgt aus:

WHERE foo=bar AND baz=taz 

Und JDBI geleitet, die wie folgt aussieht:

@UseStringTemplate3StatementLocator 
public interface ThingDAO { 
    @SqlQuery("SELECT * FROM things <where>) 
    List<Thing> findThingsWhere(@Define("where") String where); 
} 

Soweit ich verstehe, ist die aktuelle Implementierung anfällig für SQL-Injektion. Ich kann offensichtlich die Spaltennamen, aber nicht die Werte bereinigen. 1

Es muss eine elegantere und SQL-Injection-sichere Möglichkeit geben, dies zu tun.

Answer 1

Inspiriert von Jean-Bernard kam ich mit auf den Punkt:

public class WhereClause { 
    public HashMap<String, String> queryValues; // [<"foo","bar">, <"baz","taz">] 
    public String preparedString; // "WHERE foo=:foo AND bar=:baz" 
} 

, die über eine benutzerdefinierte Binder BindWhereClause gebunden ist:

@BindingAnnotation(BindWhereClause.WhereClauseBinderFactory.class) 
@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.PARAMETER}) 
public @interface BindWhereClause { 
    class WhereClauseBinderFactory implements BinderFactory { 
     public Binder build(Annotation annotation) { 
      return new Binder<BindWhereClause, WhereClause>() { 
       public void bind(SQLStatement q, BindWhereClause bind, WhereClause clause) { 
        clause.queryValues 
          .keySet() 
          .forEach(s -> q.bind(s, clause.queryValues.get(s))); 
       } 
      }; 
     } 
    } 
} 

und eine Kombination aus @Define und @Bind:

@UseStringTemplate3StatementLocator 
public interface ThingDAO { 
    @SqlQuery("SELECT * FROM things <where>) 
    List<Thing> findThingsWhere(@Define("where") String where, 
           @BindWhereClause() WhereClause whereClause); 
} 

Dies sollte spritzwassergeschützt sein. (Ist es?)

Answer 2

Verwenden Sie eine parametrisierte Abfrage. Here ist die jdbi Seite für sie.
Mit parametrisierten Abfragen können Sie die SQL-Injektion in den meisten Einstellungen verhindern.

Sie können die where-Anweisung dynamisch erstellen, aber Parameternamen anstelle von Werten lassen, sie werden später auf sichere Weise gebunden.

Sie würden wahrscheinlich in diesem Bit speziell interessiert sein, da Ihre Parameter dynamisch sind:

@BindingAnnotation(BindSomething.SomethingBinderFactory.class) 
@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.PARAMETER}) 
public @interface BindSomething 
{ 

    public static class SomethingBinderFactory implements BinderFactory 
    { 
    public Binder build(Annotation annotation) 
    { 
     return new Binder<BindSomething, Something>() 
     { 
     public void bind(SQLStatement q, BindSomething bind, Something arg) 
     { 
      q.bind("ident", arg.getId()); 
      q.bind("nom", arg.getName()); 
     } 
     }; 
    } 
    } 
} 

Ich habe noch nie verwendet jdbi so bin ich nicht 100% sicher, was Sie tun müsste, aber Es sieht so aus, als ob die Methode q.bind (...) genau das ist, was Sie wollen.