à l'aide d'un ParameterExpression par rapport à une variable en JPA Critères d'API

Lors de l'utilisation de la JPA API criteria, quel est l'avantage de l'utilisation d'un ParameterExpression sur une variable directement? E. g. quand je veux rechercher un client par son nom dans une variable de type String, je pourrais écrire quelque chose comme

private List<Customer> findCustomer(String name) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Customer> criteriaQuery = cb.createQuery(Customer.class);
    Root<Customer> customer = criteriaQuery.from(Customer.class);
    criteriaQuery.select(customer).where(cb.equal(customer.get("name"), name));
    return em.createQuery(criteriaQuery).getResultList();
}

Avec des paramètres, cela devient:

private List<Customer> findCustomerWithParam(String name) {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Customer> criteriaQuery = cb.createQuery(Customer.class);
    Root<Customer> customer = criteriaQuery.from(Customer.class);
    ParameterExpression<String> nameParameter = cb.parameter(String.class, "name");
    criteriaQuery.select(customer).where(cb.equal(customer.get("name"), nameParameter));
    return em.createQuery(criteriaQuery).setParameter("name", name).getResultList();
}

De concision, je préfère la première méthode, en particulier lorsque la requête est plus longue avec des paramètres optionnels. Quels sont les inconvénients de l'utilisation de paramètres comme ceci, comme l'injection SQL?

Je ne peux pas parler pour JPA en général, mais j'ai trouvé que OpenJPA en interne convertit un des Critères de requête JPQL, ce qui peut être imprimé à l'aide de OpenJPA de fonctionnalités spécifiques (voir la section openjpa.apache.org/builds/2.1.1/apache-openjpa/docs/...). La première requête se traduit par "SELECT c from Client c OÙ c.name = "test " Client". Cela signifie qu'il n'utilisez PAS un paramètre donc, si cela devient de plus amples traduit de SQL correspondant de l'instruction préparée à ne PAS utiliser un paramètre. La seconde version se traduit par la JPQL "SELECT c from Client c OÙ c.nom = :nom de", donc je vais utiliser des paramètres.
Après quelques essais, j'ai trouvé que l'écriture de la même requête JPQL et en utilisant le nom de "' OU 'x'='x" injecte JPQL. Lors de l'utilisation de l'API criteria, à la génération de JPQL que OpenJPA journaux semble exactement le même. Mais la réelle SQL qui est connecté par OpenJPA puis utilise une instruction préparée avec un paramètre de valeur "' OU 'x'='x" au lieu de " dans la JPQL cas. Cela signifie que l'injection SQL ne fonctionne pas ici! Malheureusement, je n'ai aucune idée de quelle est la fiabilité de ce qui est. Il semble que cette une fonctionnalité non documentée.
Astuce: j'ai juste donné querydsl.com de l'essayer et c'est la syntaxe est beaucoup plus concis et lisible. Il semble que pour se prémunir contre les injections sql en utilisant les paramètres par défaut.
C'est, si vous n'utilisez pas de paramètres, l'injection SQL est possible?

OriginalL'auteur Henno Vermeulen | 2013-05-08

  1. 0

    Lors de l'utilisation d'un paramètre, probablement (en fonction de la JPA mise en œuvre, la banque de données en cours d'utilisation, et le pilote JDBC) SQL sera optimisé pour un JDBC paramètre donc, si vous exécutez la même chose avec une autre valeur du paramètre que l'on utilise le même JDBC déclaration.

    Injection SQL est toujours vers le bas pour le développeur que pour qu'ils valident certains l'entrée d'utilisateur qui est utilisé en tant que paramètre.

    C'est une bonne chose à savoir. Je préfère plus simple de code ci-dessus le code optimisé jusqu'à ce qu'elle est identifiée comme un problème. Le problème que j'ai avec l'aide de paramètres de critères facultatifs dans la clause where est que vous devez avoir répété code comme "si (optionalParameter != null)" de déclarer et de régler le paramètre. Votre deuxième réponse me confond. J'ai toujours pensé que (jusqu'à une éventuelle mise en œuvre de bugs) paramètres ont été garantis pour ne pas souffrir d'attaques par injection SQL et je me demandais si mon plus simple première manière peut souffrir de l'injection SQL. Je suis à l'aide de OpenJPA par la voie.

    OriginalL'auteur DataNucleus

  2. 0

    vous pouvez utiliser ParameterExpression comme ceci:
    supposons que vous avez des filtre d'entrée, un exemple pourrait être celui-ci:

    • dans votre requête, vous avez pour vérifier la valeur d'un Code fiscal.

    commençons:
    tout d'abord créer criteriaQuery et criteriaBuilder et de la racine 

            CriteriaBuilder cb = _em.getCriteriaBuilder();
        CriteriaQuery<Tuple> cq = cb.createTupleQuery();
        Root<RootEntity> soggettoRoot = cq.from(RootEntity.class);

    1) inizialize un predicateList(utilisation de la clause where) et un paramList(à utiliser pour les param)

    Map<ParameterExpression,String> paramList = new HashMap();
List<Predicate> predicateList = new ArrayList<>();

    2 )vérifiez si l'entrée est nulle et de créer predicateList et param

    if( input.getFilterCF() != null){
            //create ParameterExpression
            ParameterExpression<String> cf = cb.parameter(String.class);


           //if like clause
            predicateList.add(cb.like(root.<String>get("cf"), cf));
            paramList.put(cf , input.getFilterCF() + "%");

           //if equals clause
           //predicateList.add(cb.equal(root.get("cf"), cf));   
           //paramList.put(cf,input.getFilterCF()());
        }

    3) de créer la clause where

     cq.where(cb.and(predicateList.toArray(new   Predicate[predicateList.size()])));
TypedQuery<Tuple> q = _em.createQuery(cq);

    4) jeu de param valeur

            for(Map.Entry<ParameterExpression,String> entry : paramList.entrySet())
        {
            q.setParameter(entry.getKey(), entry.getValue());
        }
    Va SQL injection sera possible que si les paramètres ne sont pas utilisés?
    oui, il sera possible

    OriginalL'auteur Taioli Francesco