AbstractApiValidator.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.utils.rest;

  23. import java.net.URL;
  24. import java.util.ArrayList;
  25. import java.util.List;

  27. import org.openspcoop2.utils.UtilsMultiException;
  28. import org.openspcoop2.utils.rest.api.Api;
  29. import org.openspcoop2.utils.rest.api.ApiBodyParameter;
  30. import org.openspcoop2.utils.rest.api.ApiCookieParameter;
  31. import org.openspcoop2.utils.rest.api.ApiHeaderParameter;
  32. import org.openspcoop2.utils.rest.api.ApiOperation;
  33. import org.openspcoop2.utils.rest.api.ApiParameterSchema;
  34. import org.openspcoop2.utils.rest.api.ApiParameterSchemaComplexType;
  35. import org.openspcoop2.utils.rest.api.ApiParameterTypeSchema;
  36. import org.openspcoop2.utils.rest.api.ApiRequestDynamicPathParameter;
  37. import org.openspcoop2.utils.rest.api.ApiRequestFormParameter;
  38. import org.openspcoop2.utils.rest.api.ApiRequestQueryParameter;
  39. import org.openspcoop2.utils.rest.api.ApiResponse;
  40. import org.openspcoop2.utils.rest.api.ApiSchemaTypeRestriction;
  41. import org.openspcoop2.utils.rest.api.ApiUtilities;
  42. import org.openspcoop2.utils.rest.entity.Cookie;
  43. import org.openspcoop2.utils.rest.entity.HttpBaseEntity;
  44. import org.openspcoop2.utils.rest.entity.HttpBaseRequestEntity;
  45. import org.openspcoop2.utils.rest.entity.HttpBaseResponseEntity;
  46. import org.openspcoop2.utils.transport.TransportUtils;
  47. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  48. import org.springframework.web.util.UriUtils;

  50. /**
  51.  * ApiValidatorConfig
  52.  *
  53.  *
  54.  * @author Poli Andrea (apoli@link.it)
  55.  * @author $Author$
  56.  * @version $Rev$, $Date$
  57.  */
  58. public abstract class AbstractApiValidator   {

  60.     public abstract void validatePreConformanceCheck(HttpBaseEntity<?> httpEntity,ApiOperation operation,Object ... args) throws ProcessingException,ValidatorException;
  61.     
  62.     public abstract void validatePostConformanceCheck(HttpBaseEntity<?> httpEntity,ApiOperation operation,Object ... args) throws ProcessingException,ValidatorException;
  63.     
  64.     public abstract void validateValueAsType(ApiParameterType parameterType, String value, String type, ApiSchemaTypeRestriction typeRestriction) throws ProcessingException,ValidatorException;
  65.     
  66.     public void validate(Api api, HttpBaseEntity<?> httpEntity, Object ... args) throws ProcessingException,ValidatorException{
  67.         
  68.         ApiOperation operation = api.findOperation(httpEntity.getMethod(), httpEntity.getUrl());
  69.         if(operation==null){
  70.             throw new ProcessingException("Resource "+httpEntity.getMethod()+" '"+httpEntity.getUrl()+"' not found");
  71.         }

  73.         // es. xsd
  74.         validatePreConformanceCheck(httpEntity, operation, args);
  75.         
  76.         validateConformanceCheck(httpEntity, operation, api.getBaseURL());
  77.         
  78.         // es. elementi specifici come nomi nel xsd etc..
  79.         validatePostConformanceCheck(httpEntity, operation, args);
  80.         
  81.     }
  82.     
  83.     private void validateConformanceCheck(HttpBaseEntity<?> httpEntity,ApiOperation operation, URL baseUrl) throws ProcessingException,ValidatorException{

  85.         try{
  86.             
  87.             
  88.             
  89.             if(httpEntity.getContentType() != null) {
  90.                 
  91.                 String baseTypeHttp = ContentTypeUtilities.readBaseTypeFromContentType(httpEntity.getContentType());
  92.                 
  93.                 boolean contentTypeSupported = false;
  94.                 List<ApiBodyParameter> requestBodyParametersList = null;
  95.                 List<ApiResponse> responses = null;
  96.                 if(operation.getRequest()!=null &&  operation.getRequest().sizeBodyParameters()>0){
  97.                     requestBodyParametersList = operation.getRequest().getBodyParameters();
  98.                 }
  99.                 if(operation.sizeResponses()>0){
  100.                     responses = operation.getResponses();
  101.                 }
  102.                 int status = -1;
  103.                 
  104.                 if(httpEntity instanceof HttpBaseRequestEntity<?>) {
  105.                                         
  106.                     if(requestBodyParametersList != null) {
  107.                         for(ApiBodyParameter input: requestBodyParametersList) {
  108.                             if(input.isAllMediaType() || ContentTypeUtilities.isMatch(null, baseTypeHttp, input.getMediaType())) {
  109.                                 contentTypeSupported = true;
  110.                                 break;
  111.                             } 
  112.                         }
  113.                     }
  114.                 } else if(httpEntity instanceof HttpBaseResponseEntity<?>) {
  115.                     status = ((HttpBaseResponseEntity<?>)httpEntity).getStatus();
  116.                     
  117.                     if(responses != null) {
  118.                         
  119.                         // Fix: se si traccia del codice http esatto non devo andare a verificare il codice di default
  120.                         
  121.                         // prima faccio la verifica con codice esatto
  122.                         ApiResponse outputDefault = null;
  123.                         boolean findExactResponseCode = false;
  124.                         for(ApiResponse output: responses) {
  125.                             if(status==output.getHttpReturnCode()) {
  126.                                 findExactResponseCode = true;
  127.                                 if(output.sizeBodyParameters()>0) {
  128.                                     for(ApiBodyParameter outputBodyParameter: output.getBodyParameters()) {
  129.                                         if(outputBodyParameter.isAllMediaType() || ContentTypeUtilities.isMatch(null, baseTypeHttp, outputBodyParameter.getMediaType()) ) {
  130.                                             contentTypeSupported = true;
  131.                                             break;
  132.                                         } 
  133.                                     }
  134.                                 }
  135.                             }
  136.                             else if(output.isDefaultHttpReturnCode()) {
  137.                                 outputDefault = output;
  138.                             }
  139.                         }
  140.                         
  141.                         // poi con l'eventuale default
  142.                         if(!contentTypeSupported && !findExactResponseCode && outputDefault!=null) {
  143.                             if(outputDefault.sizeBodyParameters()>0) {
  144.                                 for(ApiBodyParameter outputBodyParameter: outputDefault.getBodyParameters()) {
  145.                                     if(outputBodyParameter.isAllMediaType() || ContentTypeUtilities.isMatch(null, baseTypeHttp, outputBodyParameter.getMediaType()) ) {
  146.                                         contentTypeSupported = true;
  147.                                         break;
  148.                                     } 
  149.                                 }
  150.                             }
  151.                         }
  152.                     }
  153.     
  154.                 }
  155.                 
  156.                 if(!contentTypeSupported) {
  157.                     if(status>0)
  158.                         throw new ValidatorException("Content-Type '"+baseTypeHttp+"' (http response status '"+status+"') unsupported");
  159.                     else
  160.                         throw new ValidatorException("Content-Type '"+baseTypeHttp+"' unsupported");
  161.                 }
  162.             }
  163.             else {
  164.                 
  165.                 // senza content-type
  166.                 
  167.                 if(httpEntity instanceof HttpBaseRequestEntity<?>) {
  168.                     
  169.                     if(operation.getRequest()!=null &&  operation.getRequest().sizeBodyParameters()>0){
  170.                         
  171.                         boolean required = false;
  172.                         for(ApiBodyParameter input: operation.getRequest().getBodyParameters()) {
  173.                             if(input.isRequired()) {
  174.                                 required = true;
  175.                             }
  176.                         }
  177.                         if(required) {
  178.                             throw new ValidatorException("Request without payload (Content-Type 'null') unsupported");
  179.                         }
  180.                         
  181.                     }
  182.                     
  183.                 }
  184.                 
  185.                 
  186.             }
  187.             
  188.             if(httpEntity instanceof HttpBaseRequestEntity<?>) {
  189.             
  190.                 HttpBaseRequestEntity<?> request = (HttpBaseRequestEntity<?>) httpEntity;
  191.                 
  192.                 if(operation.getRequest()!=null &&  operation.getRequest().sizeHeaderParameters()>0){
  193.                     for (ApiHeaderParameter paramHeader : operation.getRequest().getHeaderParameters()) {
  194.                         String name = paramHeader.getName();
  195.                         List<String> values = TransportUtils.getRawObject(request.getHeaders(), name);
  196.                         if(values==null || values.isEmpty()){
  197.                             if(paramHeader.isRequired()){
  198.                                 throw new ValidatorException("Required http header '"+name+"' not found");
  199.                             }
  200.                         }
  201.                         else {
  202.                             for (String value : values) {
  203.                                 if(value!=null){
  204.                                     validate(paramHeader.getApiParameterSchema(), ApiParameterType.header, name, value, "http header");
  205.                                 }   
  206.                             }
  207.                         }
  208.                     }
  209.                 }
  210.                 
  211.                 if(operation.getRequest()!=null &&  operation.getRequest().sizeCookieParameters()>0){
  212.                     for (ApiCookieParameter paramCookie : operation.getRequest().getCookieParameters()) {
  213.                         String name = paramCookie.getName();
  214.                         String value = null;
  215.                         if(request.getCookies()!=null){
  216.                             for (Cookie cookie : request.getCookies()) {
  217.                                 if(name.equalsIgnoreCase(cookie.getName())){
  218.                                     value = cookie.getValue();
  219.                                 }
  220.                             }
  221.                         }
  222.                         if(value==null){
  223.                             if(paramCookie.isRequired()){
  224.                                 throw new ValidatorException("Required Cookie '"+name+"' not found");
  225.                             }
  226.                         }
  227.                         if(value!=null){
  228.                             validate(paramCookie.getApiParameterSchema(), ApiParameterType.cookie, name, value, "cookie");
  229.                         }
  230.                     }
  231.                 }
  232.                 
  233.                 if(operation.getRequest()!=null &&  operation.getRequest().sizeQueryParameters()>0){
  234.                     for (ApiRequestQueryParameter paramQuery : operation.getRequest().getQueryParameters()) {
  235.                         
  236.                         // i parametri sono esplosi. La validazione viene fatta con json o openapi  
  237.                         boolean parametriEsplosi = false;
  238.                         if(paramQuery.getApiParameterSchema()!=null && paramQuery.getApiParameterSchema().getSchemas()!=null && !paramQuery.getApiParameterSchema().getSchemas().isEmpty()) {
  239.                             for (ApiParameterTypeSchema schema : paramQuery.getApiParameterSchema().getSchemas()) {
  240.                                 // Il controllo basta farlo sul primo.
  241.                                 if(schema.getSchema()!=null && schema.getSchema().isTypeObject()) {
  242.                                     if (
  243.                                             (schema.getSchema().isStyleQueryForm() && schema.getSchema().isExplodeEnabled())
  244.                                             ||
  245.                                             (schema.getSchema().isStyleQueryDeepObject())
  246.                                             ) {
  247.                                         parametriEsplosi = true;
  248.                                         break;
  249.                                     }
  250.                                 }
  251.                             }
  252.                         }
  253.                         if(parametriEsplosi) {
  254.                             continue;
  255.                         }
  256.                         
  257.                         String name = paramQuery.getName();
  258.                         List<String> values = TransportUtils.getRawObject(request.getParameters(), name);
  259.                         if(values==null || values.isEmpty()){
  260.                             if(paramQuery.isRequired()){
  261.                                 throw new ValidatorException("Required query parameter '"+name+"' not found");
  262.                             }
  263.                         }
  264.                         else {
  265.                             for (String value : values) {
  266.                                 if(value!=null){
  267.                                     validate(paramQuery.getApiParameterSchema(), ApiParameterType.query, name, value, "query parameter");
  268.                                 }
  269.                             }
  270.                         }
  271.                     }
  272.                 }
  273.                                 
  274.                 if(operation.getRequest()!=null &&  operation.getRequest().sizeDynamicPathParameters()>0){
  275.                     for (ApiRequestDynamicPathParameter paramDynamicPath : operation.getRequest().getDynamicPathParameters()) {
  276.                         boolean find = false;
  277.                         String valueFound = null;
  278.                         if(operation.isDynamicPath()){
  279.                             for (int i = 0; i < operation.sizePath(); i++) {
  280.                                 if(operation.isDynamicPath()){
  281.                                     String idDinamic = operation.getDynamicPathId(i);
  282.                                     if(paramDynamicPath.getName().equals(idDinamic)){
  283.                                         String [] urlList = ApiUtilities.extractUrlList(baseUrl, request.getUrl());
  284.                                         if(i>=urlList.length){
  285.                                             throw new ValidatorException("Dynamic path '"+paramDynamicPath.getName()+"' not found (position:"+i+", urlLenght:"+urlList.length+")");
  286.                                         }
  287.                                         find = true;
  288.                                         valueFound = urlList[i];
  289.                                         break;
  290.                                     }
  291.                                 }
  292.                             }
  293.                         }
  294.                         if(!find && paramDynamicPath.isRequired()){
  295.                             throw new ValidatorException("Required dynamic path '"+paramDynamicPath.getName()+"' not found");
  296.                         }
  297.                         if(find){
  298.                             String valueUrlDecoded = valueFound;
  299.                             // il valore può essere url encoded
  300.                             try {
  301.                                 // Note that Java’s URLEncoder class encodes space character(" ") into a + sign. 
  302.                                 // This is contrary to other languages like Javascript that encode space character into %20.
  303.                                 /*
  304.                                  *  URLEncoder is not for encoding URLs, but for encoding parameter names and values for use in GET-style URLs or POST forms. 
  305.                                  *  That is, for transforming plain text into the application/x-www-form-urlencoded MIME format as described in the HTML specification. 
  306.                                  **/
  307.                                 //valueUrlDecoded = java.net.URLDecoder.decode(valueFound, org.openspcoop2.utils.resources.Charset.UTF_8.getValue());
  308.                                 
  309.                                 valueUrlDecoded = UriUtils.decode(valueFound, org.openspcoop2.utils.resources.Charset.UTF_8.getValue());
  310.                                 
  311.                                 //System.out.println("DOPO '"+valueUrlDecoded+"' PRIMA '"+valueFound+"'");
  312.                                 
  313.                             }catch(Throwable e) {
  314.                                 //System.out.println("ERRORE");
  315.                                 //e.printStackTrace(System.out);
  316.                                 // utilizzo valore originale
  317.                                 //throw new RuntimeException(e.getMessage(),e);
  318.                             }
  319.                             validate(paramDynamicPath.getApiParameterSchema(), ApiParameterType.path, paramDynamicPath.getName(), valueUrlDecoded, "dynamic path",
  320.                                     (valueUrlDecoded!=null && !valueUrlDecoded.equals(valueFound)) ? valueFound : null);
  321.                         }
  322.                     }
  323.                 }
  324.                 
  325.                 if(operation.getRequest()!=null &&  operation.getRequest().sizeFormParameters()>0){
  326.                     for (ApiRequestFormParameter paramForm : operation.getRequest().getFormParameters()) {
  327.                         String name = paramForm.getName();
  328.                         List<String> values = TransportUtils.getRawObject(request.getParameters(), name);
  329.                         if(values==null || values.isEmpty()){
  330.                             if(paramForm.isRequired()){
  331.                                 throw new ValidatorException("Required form parameter '"+name+"' not found");
  332.                             }
  333.                         }
  334.                         else {
  335.                             for (String value : values) {
  336.                                 if(value!=null){
  337.                                     validate(paramForm.getApiParameterSchema(), ApiParameterType.form, name, value, "form parameter");
  338.                                 }
  339.                             }
  340.                         }
  341.                     }
  342.                 }
  343.                 
  344.             }
  345.             
  346.             if(httpEntity instanceof HttpBaseResponseEntity<?>) {
  347.                 
  348.                 HttpBaseResponseEntity<?> response = (HttpBaseResponseEntity<?>) httpEntity;
  349.                 ApiResponse apiResponseFound = null;
  350.                 ApiResponse apiResponseDefault = null;
  351.                 
  352.                 for (ApiResponse apiResponse : operation.getResponses()) {
  353.                     if(apiResponse.isDefaultHttpReturnCode()) {
  354.                         apiResponseDefault = apiResponse;
  355.                     }
  356.                     if(response.getStatus() == apiResponse.getHttpReturnCode()){
  357.                         apiResponseFound = apiResponse;
  358.                         break;
  359.                     }                                       
  360.                 }
  361.                 
  362.                 if(apiResponseFound==null && apiResponseDefault!=null) {
  363.                     apiResponseFound = apiResponseDefault;
  364.                 }
  365.                 if(apiResponseFound==null){
  366.                     throw new ValidatorException("Http status code '"+response.getStatus()+"' unsupported");
  367.                 }
  368.                 
  369.                 if(apiResponseFound.sizeHeaderParameters()>0){
  370.                     for (ApiHeaderParameter paramHeader : apiResponseFound.getHeaderParameters()) {
  371.                         String name = paramHeader.getName();
  372.                         List<String> values = TransportUtils.getRawObject(response.getHeaders(), name);
  373.                         if(values==null || values.isEmpty()){
  374.                             if(paramHeader.isRequired()){
  375.                                 throw new ValidatorException("Required http header '"+name+"' not found");
  376.                             }
  377.                         }
  378.                         else {
  379.                             for (String value : values) {
  380.                                 if(value!=null){
  381.                                     validate(paramHeader.getApiParameterSchema(), ApiParameterType.header, name, value, "http header");
  382.                                 }
  383.                             }
  384.                         }
  385.                     }
  386.                 }
  387.                 
  388.                 if(apiResponseFound.sizeCookieParameters()>0){
  389.                     for (ApiCookieParameter paramCookie : apiResponseFound.getCookieParameters()) {
  390.                         String name = paramCookie.getName();
  391.                         String value = null;
  392.                         if(response.getCookies()!=null){
  393.                             for (Cookie cookie : response.getCookies()) {
  394.                                 if(name.equalsIgnoreCase(cookie.getName())){
  395.                                     value = cookie.getValue();
  396.                                 }
  397.                             }
  398.                         }
  399.                         if(value==null){
  400.                             if(paramCookie.isRequired()){
  401.                                 throw new ValidatorException("Required cookie '"+name+"' not found");
  402.                             }
  403.                         }
  404.                         if(value!=null){
  405.                             validate(paramCookie.getApiParameterSchema(), ApiParameterType.cookie, name, value, "cookie");
  406.                         }
  407.                     }
  408.                 }
  409.                 
  410.             }

  412.         }catch(ProcessingException e){
  413.             throw e;
  414.         }catch(ValidatorException e){
  415.             throw e;
  416.         }catch(Exception e){
  417.             throw new ProcessingException(e.getMessage(),e);
  418.         }
  419.         
  420.     }
  421.     
  422.     
  423.     private void validate(ApiParameterSchema apiParameterSchema, ApiParameterType type, String name, String value, String position) throws ValidatorException, ProcessingException {
  424.         this.validate(apiParameterSchema, type, name, value, position, null);
  425.     }
  426.     private void validate(ApiParameterSchema apiParameterSchema, ApiParameterType type, String name, String value, String position, String valueUrlEncoded) throws ValidatorException, ProcessingException {
  427.         if(apiParameterSchema!=null && apiParameterSchema.getSchemas()!=null && !apiParameterSchema.getSchemas().isEmpty()) {
  428.             ApiParameterSchemaComplexType ct = apiParameterSchema.getComplexType();
  429.             if(ct==null) {
  430.                 ct = ApiParameterSchemaComplexType.simple;
  431.             }
  432.             
  433.             String prefixError = "Invalid value '"+value+"' in "+position+" '"+name+"'";
  434.             if(valueUrlEncoded!=null) {
  435.                  prefixError = "Invalid value '"+value+"' (urlEncoded: '"+valueUrlEncoded+"') in "+position+" '"+name+"'";
  436.             }
  437.             
  438.             switch (ct) {
  439.             case simple: // caso speciale con 1 solo
  440.             case allOf:
  441.                 StringBuilder sbException = new StringBuilder();
  442.                 List<ValidatorException> listValidatorException = new ArrayList<ValidatorException>();
  443.                 for (ApiParameterTypeSchema schema : apiParameterSchema.getSchemas()) {
  444.                     try{
  445.                         validateValueAsType(type, value, schema.getType(),schema.getSchema());
  446.                     }catch(ValidatorException val){
  447.                         String msgError = prefixError+" (expected type '"+schema.getType()+"'): "+val.getMessage();
  448.                         if(sbException.length()>0) {
  449.                             sbException.append("\n");
  450.                         }
  451.                         sbException.append(msgError);
  452.                         listValidatorException.add( new ValidatorException(msgError,val) );
  453.                     }   
  454.                 }
  455.                 if(!listValidatorException.isEmpty()) {
  456.                     UtilsMultiException multi = new UtilsMultiException(listValidatorException.toArray(new ValidatorException[1]));
  457.                     throw new ValidatorException(sbException.toString(), multi);
  458.                 }
  459.                 return;
  460.                 
  461.             case anyOf:
  462.                 sbException = new StringBuilder();
  463.                 listValidatorException = new ArrayList<ValidatorException>();
  464.                 for (ApiParameterTypeSchema schema : apiParameterSchema.getSchemas()) {
  465.                     try{
  466.                         validateValueAsType(type, value, schema.getType(),schema.getSchema());
  467.                         return; // ne basta una che valida correttamente
  468.                     }catch(ValidatorException val){
  469.                         String msgError = prefixError+" (expected type '"+schema.getType()+"'): "+val.getMessage();
  470.                         if(sbException.length()>0) {
  471.                             sbException.append("\n");
  472.                         }
  473.                         sbException.append(msgError);
  474.                         listValidatorException.add( new ValidatorException(msgError,val) );
  475.                     }   
  476.                 }
  477.                 if(!listValidatorException.isEmpty()) {
  478.                     UtilsMultiException multi = new UtilsMultiException(listValidatorException.toArray(new ValidatorException[1]));
  479.                     throw new ValidatorException(sbException.toString(), multi);
  480.                 }
  481.                 return; //caso che non può accadere
  482.                 
  483.             case oneOf:
  484.                 sbException = new StringBuilder();
  485.                 listValidatorException = new ArrayList<ValidatorException>();
  486.                 int schemiValidi = 0;
  487.                 for (ApiParameterTypeSchema schema : apiParameterSchema.getSchemas()) {
  488.                     try{
  489.                         validateValueAsType(type, value, schema.getType(),schema.getSchema());
  490.                         schemiValidi++;
  491.                     }catch(ValidatorException val){
  492.                         String msgError = prefixError+" (expected type '"+schema.getType()+"'): "+val.getMessage();
  493.                         if(sbException.length()>0) {
  494.                             sbException.append("\n");
  495.                         }
  496.                         sbException.append(msgError);
  497.                         listValidatorException.add( new ValidatorException(msgError,val) );
  498.                     }   
  499.                 }
  500.                 if(schemiValidi==0) {
  501.                     if(!listValidatorException.isEmpty()) {
  502.                         UtilsMultiException multi = new UtilsMultiException(listValidatorException.toArray(new ValidatorException[1]));
  503.                         throw new ValidatorException(sbException.toString(), multi);
  504.                     }
  505.                     else {
  506.                         throw new ValidatorException(prefixError);
  507.                     }
  508.                 }
  509.                 else if(schemiValidi>1) {
  510.                     throw new ValidatorException(prefixError+": expected validates the value against exactly one of the subschemas; founded valid in "+schemiValidi+" schemas");
  511.                 }
  512.                 return; // deve essere validato rispetto esattamente ad uno schema

  514.             }
  515.         }

  517.         

  519.     }
  520. }
Created with JaCoCo 0.8.8.202204050719