1.【黑客编程】手把手教你编写POC
2.DVWA Command Injection 攻略
3.Java FreeMarker模板引擎注入深入分析
4.如何判断是否存在SQL注入以及注入类型？
5.从源码层面带你实现一个自动注入注解

【黑客编程】手把手教你编写POC

       黑客编程手把手教你编写POC：从入门到实践

       POC，即Proof of concept，是安全领域中验证漏洞的一种工具，它并非完整的程序，而是为了验证观点而编写的代码片段。本文将指导你如何在DVWA（Damn Vulnerable Web App）这个安全测试环境中，flash围棋源码通过分析漏洞并编写验证程序，来理解并实践POC的使用。

       首先，DVWA是一个PHP/MySQL Web应用，常用于安全测试。利用DVWA中的Command Injection漏洞进行验证，我们可以通过修改Security设置为low，然后通过拼接参数触发漏洞。源码分析显示，c 源码 讲解ip参数未经过过滤，导致命令执行函数shell_exec存在漏洞。

       接下来，使用Python项目，通过分析HTTP数据包来理解漏洞请求。在Firefox的Firebug中观察到POST请求包，注意到/vulnerabilities/exec/接口存在权限问题。为获取访问权限，需要模拟登录，将Cookie信息添加到请求头中。

       编写验证程序时，我们遇到了状态码而非的问题。通过分析，我们了解到这是源码防解密由于未授权导致的重定向。为快速识别漏洞，可以采用两种方法：特征检测法，匹配返回结果中的特定字符；关键输出法，人工判断关键信息以确认漏洞利用是否成功。

       总结来说，编写POC是渗透测试中的实用技能，虽然渗透测试本身难以完全自动化，但通过编写小工具可以显著提高效率。掌握一门编程语言对于成为合格的白帽渗透测试者至关重要。

DVWA Command Injection 攻略

       DVWA Command Injection漏洞详解

       初级阶段的漏洞在于服务器对用户输入的IP参数未做充分过滤。通过查看源代码，我们发现服务器通过操作系统差异执行ping命令，但允许了未经过滤的命令注入，如使用"&&"。ar 项目源码漏洞示例如下：

       $cmd = "ping { $target}"; // 未做过滤

       中级阶段，服务器尝试通过黑名单机制改进，移除了"&&"和";"。然而，利用"&"或 "|" 连接符，攻击者依旧可以绕过过滤，如:

       $cmd = "ping -c 4 { $target}"; // 黑名单机制

       高级阶段，虽然黑名单添加了更多字符，但"|"（后面带空格）依然成为漏网之鱼。代码示例：

       $cmd = "ping -c 4 { $target}"; // 黑名单中漏掉的 "|"

       为了完全防御此类攻击，代码引入了Anti-CSRF令牌和输入验证。例如，只有经过验证的IP地址才能执行ping操作:

       if (is_valid_ip($target)) {

        // 生成和检查Anti-CSRF令牌

        $cmd = "ping -c 4 { $target}";

       } else {

        echo "ERROR: Invalid IP.";

       }

       // 生成Anti-CSRF令牌

       generateSessionToken();

       这段代码通过多重防护手段提高了防御等级，但仍需警惕攻击者可能找到的maven ssh源码其他绕过方法。

Java FreeMarker模板引擎注入深入分析

       深入理解Java FreeMarker模板引擎的注入漏洞

       在漏洞挖掘和安全研究中，FreeMarker模板引擎的注入问题引起了关注。相比于其他模板引擎，如Thymeleaf，FreeMarker的注入攻击机制有所不同。本文主要聚焦于FreeMarker的SSTI（Site-Specific Template Injection）。

       FreeMarker 2.3.版本是本文研究的基础，它的工作原理涉及插值和FTL指令。插值允许数据模型中的数据替换输出，如在.ftl文件中使用${ name}。FTL指令则像HTML一样，但以#开头，提供了更丰富的功能。然而，FreeMarker SSTI的触发需要特定的攻击流程：首先，HTML需要被引入服务器，可通过上传文件或利用带有模板编辑功能的CMS。

       攻击的关键在于，FreeMarker SSTI不像Thymeleaf那样仅通过传参就能触发RCE。它需要将HTML转化为模板才能触发漏洞。环境搭建需要一定的基础，但这里未详述，推荐自行查阅。漏洞复现过程表明，攻击需要将HTML插入模板文件中，且利用了freemarker.template.utility.Execute类中的命令执行方法。

       漏洞分析涉及MVC架构和FreeMarker的模板加载流程。通过Spring的DispatcherServlet，HTML被转化为FreeMarkerView实例，然后在processTemplate和process方法中进行渲染。其中，对FTL表达式的处理涉及复杂的visit和eval方法，这些步骤确保了命令执行的条件和安全性。

       FreeMarker的内置函数new和api为攻击者提供了可能，但官方在2.3.版本后默认禁用了api函数的使用，以加强防护。通过设置TemplateClassResolver，可以限制对某些危险类的解析，从而减少攻击面。

       小结：FreeMarker的SSTI防护相对严格，尽管存在攻击面，但其内置的防护机制和版本更新为安全提供了保障。深入研究FreeMarker源码是了解其安全特性和可能绕过的必要步骤。

如何判断是否存在SQL注入以及注入类型？

       许多网站程序在编写时，没有对用户输入数据的合法性进行判断，使应用程序存在安全隐患。用户可以提交一段数据库查询代码，根据程序返回的结果，获得某些想得知的数据，这就是所谓的SQL Injection，即SQL注入。如何判断网站是否存在POST注入呢！请看以下步骤操作做。

       POST注入操作介绍:

       1.POST注入一般发生在表单数据传输时、抓取POST提交的数据进行SQL语句测试

       POST注入操作流程:

       比如抓取的POST数据为:userName=admin&password=admin

       测试诸如语句填写:userName=admin&password='admin 1=1--

       像这样userName 参数后面加一些SQL语句(注入测试语句)进行POST数据注入测试即可。

从源码层面带你实现一个自动注入注解

       首先，需要了解到的是。SpringBean的生命周期

       在生命周期中。注入bean属性的位置是在以下代码：populateBean位置中

       那么我们在项目中使用注解产生一个bean的时候必定会经过以下代码进行一个bean的创建流程

/**省略代码**///开始初始化bean实例对象ObjectexposedObject=bean;try{ //<5>对bean进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性populateBean(beanName,mbd,instanceWrapper);//<6>调用初始化方法exposedObject=initializeBean(beanName,exposedObject,mbd);}catch(Throwableex){ if(exinstanceofBeanCreationException&&beanName.equals(((BeanCreationException)ex).getBeanName())){ throw(BeanCreationException)ex;}else{ thrownewBeanCreationException(mbd.getResourceDescription(),beanName,"Initializationofbeanfailed",ex);}}/**省略代码**/

       在生命周期中populateBean进行填充bean数据。把其他依赖引入进来

       BeanPostProcessor是一个bean创建时候的一个钩子。

       以下代码是循环调用实现了BeanPostProcessor子类InstantiationAwareBeanPostProcessor#postProcessProperties方法

       Spring在以下代码中有自动注入的拓展点。关键就是实现InstantiationAwareBeanPostProcessor#postProcessProperties

/**省略代码**/for(BeanPostProcessorbp:getBeanPostProcessors()){ if(bpinstanceofInstantiationAwareBeanPostProcessor){ InstantiationAwareBeanPostProcessoribp=(InstantiationAwareBeanPostProcessor)bp;//对所有需要依赖检查的属性进行后处理PropertyValuespvsToUse=ibp.postProcessProperties(pvs,bw.getWrappedInstance(),beanName);if(pvsToUse==null){ //从bw对象中提取PropertyDescriptor结果集//PropertyDescriptor：可以通过一对存取方法提取一个属性if(filteredPds==null){ filteredPds=filterPropertyDescriptorsForDependencyCheck(bw,mbd.allowCaching);}pvsToUse=ibp.postProcessPropertyValues(pvs,filteredPds,bw.getWrappedInstance(),beanName);if(pvsToUse==null){ return;}}pvs=pvsToUse;}}/**省略代码**/

       我们展开来讲一下@Autowired的实现是怎么样的吧：

       实现类为AutowiredAnnotationBeanPostProcessor.java

       从上面可以得知，填充bean的时候。时调用了方法ibp.postProcessPropertyValues()

       那么AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues()则会被调用

       调用findAutowiringMetadata获取class以及父类带有@Autowired或者@Value的属性或者方法：

/**省略代码**/publicPropertyValuespostProcessProperties(PropertyValuespvs,Objectbean,StringbeanName){ //获取所有可以注入的元数据InjectionMetadatametadata=findAutowiringMetadata(beanName,bean.getClass(),pvs);try{ //注入数据metadata.inject(bean,beanName,pvs);}catch(BeanCreationExceptionex){ throwex;}catch(Throwableex){ thrownewBeanCreationException(beanName,"Injectionofautowireddependenciesfailed",ex);}returnpvs;}privateInjectionMetadatafindAutowiringMetadata(StringbeanName,Class<?>clazz,@NullablePropertyValuespvs){ //缓存名字获取StringcacheKey=(StringUtils.hasLength(beanName)?beanName:clazz.getName());InjectionMetadatametadata=this.injectionMetadataCache.get(cacheKey);//获取是否已经读取过这个class类的InjectionMetadata有的话直接从缓存中获取出去if(InjectionMetadata.needsRefresh(metadata,clazz)){ synchronized(this.injectionMetadataCache){ //双重检查metadata=this.injectionMetadataCache.get(cacheKey);if(InjectionMetadata.needsRefresh(metadata,clazz)){ if(metadata!=null){ metadata.clear(pvs);}//构建自动注入的元数据metadata=buildAutowiringMetadata(clazz);this.injectionMetadataCache.put(cacheKey,metadata);}}}returnmetadata;}privateInjectionMetadatabuildAutowiringMetadata(finalClass<?>clazz){ if(!AnnotationUtils.isCandidateClass(clazz,this.autowiredAnnotationTypes)){ returnInjectionMetadata.EMPTY;}List<InjectionMetadata.InjectedElement>elements=newArrayList<>();Class<?>targetClass=clazz;do{ finalList<InjectionMetadata.InjectedElement>currElements=newArrayList<>();//循环targetClass的所有field并执FieldCallback逻辑（函数式编程接口，传入的是一个执行函数）ReflectionUtils.doWithLocalFields(targetClass,field->{ //获得字段上面的Annotation注解MergedAnnotation<?>ann=findAutowiredAnnotation(field);if(ann!=null){ //判断是否为静态属性如果是，则不进行注入if(Modifier.isStatic(field.getModifiers())){ if(logger.isInfoEnabled()){ logger.info("Autowiredannotationisnotsupportedonstaticfields:"+field);}return;}//注解是否为必须依赖项booleanrequired=determineRequiredStatus(ann);currElements.add(newAutowiredFieldElement(field,required));}});//循环targetClass的所有Method并执MethodCallback逻辑（函数式编程接口，传入的是一个执行函数）ReflectionUtils.doWithLocalMethods(targetClass,method->{ MethodbridgedMethod=BridgeMethodResolver.findBridgedMethod(method);if(!BridgeMethodResolver.isVisibilityBridgeMethodPair(method,bridgedMethod)){ return;}MergedAnnotation<?>ann=findAutowiredAnnotation(bridgedMethod);if(ann!=null&&method.equals(ClassUtils.getMostSpecificMethod(method,clazz))){ //判断是否为静态方法如果是，则不进行注入if(Modifier.isStatic(method.getModifiers())){ if(logger.isInfoEnabled()){ logger.info("Autowiredannotationisnotsupportedonstaticmethods:"+method);}return;}//判断静态方法参数是否为0if(method.getParameterCount()==0){ if(logger.isInfoEnabled()){ logger.info("Autowiredannotationshouldonlybeusedonmethodswithparameters:"+method);}}booleanrequired=determineRequiredStatus(ann);PropertyDescriptorpd=BeanUtils.findPropertyForMethod(bridgedMethod,clazz);currElements.add(newAutowiredMethodElement(method,required,pd));}});//数据加到数组最前方父类的的注解都放在靠前的位置elements.addAll(0,currElements);//如果有父类则设置targetClass为父类。如此循环targetClass=targetClass.getSuperclass();}while(targetClass!=null&&targetClass!=Object.class);returnInjectionMetadata.forElements(elements,clazz);}/**省略代码**/

       真正注入数据的是metadata.inject(bean,beanName,pvs);

       调用的是InjectionMetadata#inject方法

publicvoidinject(Objecttarget,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{ Collection<InjectedElement>checkedElements=this.checkedElements;//带有注解的方法或者属性列表Collection<InjectedElement>elementsToIterate=(checkedElements!=null?checkedElements:this.injectedElements);if(!elementsToIterate.isEmpty()){ for(InjectedElementelement:elementsToIterate){ element.inject(target,beanName,pvs);}}}

       循环调用之前加入的带有注解的方法或者属性构建的对象AutowiredFieldElement#inject，AutowiredMethodElement#inject

/***属性上有注解构建的处理对象*/privateclassAutowiredFieldElementextendsInjectionMetadata.InjectedElement{ privatefinalbooleanrequired;privatevolatilebooleancached;@NullableprivatevolatileObjectcachedFieldValue;publicAutowiredFieldElement(Fieldfield,booleanrequired){ super(field,null);this.required=required;}@Overrideprotectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{ //获取属性名Fieldfield=(Field)this.member;Objectvalue;//Bean不是单例的话，会重复进入注入的这个操作，if(this.cached){ try{ value=resolvedCachedArgument(beanName,this.cachedFieldValue);}catch(NoSuchBeanDefinitionExceptionex){ //Unexpectedremovaloftargetbeanforcachedargument->re-resolvevalue=resolveFieldValue(field,bean,beanName);}}else{ //首次创建的时候进入该方法value=resolveFieldValue(field,bean,beanName);}if(value!=null){ //属性如果不为public的话，则设置为可访问ReflectionUtils.makeAccessible(field);field.set(bean,value);}}@NullableprivateObjectresolveFieldValue(Fieldfield,Objectbean,@NullableStringbeanName){ //构建DependencyDescriptor对象DependencyDescriptordesc=newDependencyDescriptor(field,this.required);desc.setContainingClass(bean.getClass());//注入bean的数量。有可能字段上是一个ListSet<String>autowiredBeanNames=newLinkedHashSet<>(1);Assert.state(beanFactory!=null,"NoBeanFactoryavailable");//获得beanFactory类型转换类TypeConvertertypeConverter=beanFactory.getTypeConverter();Objectvalue;try{ //查找依赖关系value=beanFactory.resolveDependency(desc,beanName,autowiredBeanNames,typeConverter);}catch(BeansExceptionex){ thrownewUnsatisfiedDependencyException(null,beanName,newInjectionPoint(field),ex);}synchronized(this){ if(!this.cached){ ObjectcachedFieldValue=null;if(value!=null||this.required){ cachedFieldValue=desc;//填入依赖关系registerDependentBeans(beanName,autowiredBeanNames);//判断如果注入依赖是只有一个if(autowiredBeanNames.size()==1){ StringautowiredBeanName=autowiredBeanNames.iterator().next();if(beanFactory.containsBean(autowiredBeanName)&&beanFactory.isTypeMatch(autowiredBeanName,field.getType())){ cachedFieldValue=newShortcutDependencyDescriptor(desc,autowiredBeanName,field.getType());}}}this.cachedFieldValue=cachedFieldValue;this.cached=true;}}returnvalue;}}/***方法上有注解构建的处理对象*/privateclassAutowiredMethodElementextendsInjectionMetadata.InjectedElement{ privatefinalbooleanrequired;privatevolatilebooleancached;@NullableprivatevolatileObject[]cachedMethodArguments;publicAutowiredMethodElement(Methodmethod,booleanrequired,@NullablePropertyDescriptorpd){ super(method,pd);this.required=required;}@Overrideprotectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{ //检查属性是不会在之前就已经注入过了。如果主如果则不进行二次覆盖if(checkPropertySkipping(pvs)){ return;}Methodmethod=(Method)this.member;Object[]arguments;if(this.cached){ try{ arguments=resolveCachedArguments(beanName);}catch(NoSuchBeanDefinitionExceptionex){ //Unexpectedremovaloftargetbeanforcachedargument->re-resolvearguments=resolveMethodArguments(method,bean,beanName);}}else{ //首次创建的时候进入该方法arguments=resolveMethodArguments(method,bean,beanName);}if(arguments!=null){ try{ //属性如果不为public的话，则设置为可访问ReflectionUtils.makeAccessible(method);//调用方法并传入参数method.invoke(bean,arguments);}catch(InvocationTargetExceptionex){ throwex.getTargetException();}}}@NullableprivateObject[]resolveCachedArguments(@NullableStringbeanName){ Object[]cachedMethodArguments=this.cachedMethodArguments;if(cachedMethodArguments==null){ returnnull;}Object[]arguments=newObject[cachedMethodArguments.length];for(inti=0;i<arguments.length;i++){ arguments[i]=resolvedCachedArgument(beanName,cachedMethodArguments[i]);}returnarguments;}@NullableprivateObject[]resolveMethodArguments(Methodmethod,Objectbean,@NullableStringbeanName){ //获取方法上有几个参数intargumentCount=method.getParameterCount();Object[]arguments=newObject[argumentCount];DependencyDescriptor[]descriptors=newDependencyDescriptor[argumentCount];Set<String>autowiredBeans=newLinkedHashSet<>(argumentCount);Assert.state(beanFactory!=null,"NoBeanFactoryavailable");TypeConvertertypeConverter=beanFactory.getTypeConverter();for(inti=0;i<arguments.length;i++){ //方法参数，从方法参数中取出i构造MethodParameter对象MethodParametermethodParam=newMethodParameter(method,i);DependencyDescriptorcurrDesc=newDependencyDescriptor(methodParam,this.required);currDesc.setContainingClass(bean.getClass());descriptors[i]=currDesc;try{ //获取方法中i参数的内容Objectarg=beanFactory.resolveDependency(currDesc,beanName,autowiredBeans,typeConverter);if(arg==null&