¡A continuación, el artículo anterior de producción del código de verificación Java (Parte 1) le presentará conocimiento relevante sobre el código de verificación Java!
Método 3:
Implementado con el componente de código abierto JCaptcha, combinado con Spring, puede generar varias formas de códigos de verificación. JCaptcha es la versión Java del Proyecto Captcha. Es un proyecto de código abierto que admite la generación de códigos de verificación para gráficos y versiones de sonido. Al generar códigos de verificación para versiones de sonido, se requiere Freetts. La prueba completa de Turing Public Turing de Captcha para decirle a las computadoras y humanos aparte se utilizó por primera vez como un proyecto de investigación científica en la Universidad Carnegie Mellon. Se usó para generar una prueba que sea fácil para los humanos, pero difícil de pasar por las computadoras. Actualmente se utiliza ampliamente en aplicaciones de red y se utiliza para evitar que los robots publiquen información de spam. Actualmente, el sitio web oficial de JCaptcha muestra que hay la versión 2.0, pero la versión binaria es solo la versión 1.0 para descargar.
Primero necesitamos preparar el paquete jar correspondiente
En la implementación del proyecto JCAPTCHA, también hace referencia a dos proyectos de código abierto, colecciones comunes y registro de bienes comunes. Además, la implementación de JCaptcha en sí, necesitamos tres paquetes en total, y la información específica es la siguiente:
JCAPTCHA-2.0-ALL.JARCOMMONS-LOGGING-1.1.1.JARCOMMONS-COLLECHIONS-3.2.JAR
En segundo lugar, veamos la información de configuración clave en el Web.xml a continuación: además de configurar la ruta de clase específica del componente JCaptCha, el SubtItMacionServlet también se configura, que se utiliza como servlet para códigos de verificación de comparación, y ambos están asignados. Se puede entender como cambiar el nombre. Al llamar al componente o servlet en /jcaptcha.jpg y /submit.action, respectivamente, se puede usar directamente para usar este nombre de mapeo.
<Servlet> <Servlet-name> jCaptcha </Servlet-Name> <Servlet-Class> com.octo.captcha.module.servlet.image.simpleimageCaptchaservlet </servlet-class> </servlet> <ervlet> <servlet-name> show </servlet-name> <Servlet-class> com.octo.captcha.module.servlet.image.sample.subMitActionServlet </servlet-class> </servlet> <servlet-mapping> <ervlet-name> jCaptcha </servlet-name> <url-pattern> /jcaaptcha.jpg </ url-pattern> </servlet-mapping> <Rl-pattern> /jCaptcha.jpg </ url-pattern> </servlet-mapping> <Rl-Pattern> /jCaptcha.jpg </ url-pattern> </servlet-mapping> <Rl-Pattern> /jCaptcha.jpg </ url-pattern> </servlet-mapping> <Rl-Pattern> /jCaptcha <Servlet-Name> Enviar </Servlet-Name> <URL-Pattern> /SubMit.Action </url-Pattern> </servlet-mapping>
web.xml
Luego, veamos cómo se implementa SubtitActionServlet: dado que se importa el paquete de componente JCAPTCHA, el método encapsulado SimpleImageCaptchAservlet.ValidaterSponse (solicitud, UserCaptCharesponse) se llama directamente para determinar si la información en el código de verificación coincide con la sumisión, sin considerar el proceso de implementación específico.
Public Class SubtItionServlet extiende httpservlet {protegido void dopost (httpservletRequest solicitud, respuesta httpServletResponse) lanza ServletException, ioexception {string UserCaptCharponse = request.getParameter ("japtcha"); boolean CaptChapassed = SimpleImageCaptchAservlet.ValidaterSponse (solicitud, UserCaptCharesponse); if (CaptChapassed) Response.getWriter (). Write ("Captcha pasada"); else {Response.getWriter (). Write ("Captcha falló"); } respuesta.getWriter (). Write ("<br/> <a href = 'index.jsp'> intente nuevamente </a>"); }} SugitActionServlet Finalmente, echemos un vistazo a la simple llamada de recepción:
<html> <body> <h> Simple Servlet Sample </h> <form action = "Subt.action" Method = "Post"> <img src = "jCaptcha.jpg"/> <input type = "text" name = "japtcha" value = ""/> <input type = "show"/> </form> </body> </html>
Leyenda de implementación:
Método 4:
Implementado con el componente de código abierto kaptcha. También el uso de kaptcha requiere descargar su paquete de componentes jar. Kaptcha es una herramienta de generación de código de verificación muy práctica. Con él, puede generar códigos de verificación de varios estilos porque es configurable. El principio de Kaptcha Works es llamar a com.google.code.kaptcha.servlet.kaptchaservlet (se puede ver que es un proyecto de código abierto de Google) para generar una imagen. Al mismo tiempo, coloque la cadena de código de verificación generada en httpsession.
Use kaptcha para configurarlo convenientemente:
Código de verificación Tamaño de la fuente Código de verificación Tamaño de la fuente Código de verificación Font Código de color del color Rango de contenido (número, letra, caracteres chino) Tamaño de imagen del código de verificación, borde, espesor de borde, línea de interferencia de código de verificación de color de borde (puede inherir a com.google.code.kaptcha.noisePrroducer para escribir una línea de interferencia personalizada) com.google.code.kaptcha.gimpyengine estilo personalizado)
...
La información de configuración para Kaptcha también se coloca en Web.xml: la información de configuración inicializada en la etiqueta <Init-Param>.
<Servlet> <Servlet-name> Kaptcha </servlet-name> <ervlet-class> com.google.code.kaptcha.servlet.kaptchaservlet </servlet-class> <ic-param> <dudion> border de imagen, valor legal: sí, no </descripción> <amarram-name> kaptcha.border </param-name> <amam-value <yes </param-value> </init-param> <init-param> <Scuion> Color de borde, valor legal: r, g, b (y alfa opcional) o blanco, negro, azul. </description> <amamname> kaptcha.border.color </param-name> <amam-value> black </amam-value> </it-param> <initparam> <itel-param> <cription> border espesor, valor legal:>/description> <amamname> kaptcha.border.thickness </paramname> <amam-value> </param-value> </init-param> <init-param> <initparam> <cription> width de imagen </description> <amamname> kaptcha.image.width </param-name> <amam-value> </param-value> </it-param> <itparam> <scription> Image </cription> <Param-Name> kaptcha.image.heheight </param-vight </param> <Amam-Value> </param-value> </init-param> <Init-Param> <Scuidtion> Clase de implementación de imágenes </cription> <Param-name> kaptcha.producer.impl </paramname> <amam-value> com.google.code.kaptcha.iMpl.defaultkaptcha </param-value> </</titic-param> <icoltic> <itrosation> <icinte> <icoltion> <itrosation> <icoly-Param> <Sitic-Param> <Sitic-Param> <Sitic-Param> <Adicate> <Sitic-Param> <Sitic-Param> <Sitic-Param> <AxtiEd-Param> <Sitic-Param> <Sitic-Param> <AxtiET-Param> Clase de implementación </description> <amamname> kaptcha.textproducer.impl </param-name> <amam-value> com.google.code.kaptcha.text.impl.defaFaultTextCreator </param-value> </init-param> <init-param> <Scoltion> La recopilación de texto de texto, el valor de verificación se obtiene de esta colección </description </descripción </descripción </param> <init-param> <Rueca> La recopilación de textos, el valor de verificación, se obtiene de esta colección </description </descripción de la descripción> </param> <init-param> <Shruchion>. <Amam-name> kaptcha.TextProducer.char.string </amamname> <amam-value> </param-value> <!-<param-value> abcdegfynmnpwx </armar-value>-> <!-<parámina-value> mooch.com tutorial verification code ejemplo </param-value>-> </</initel-param> <Scuion> La longitud del código de verificación </cription> <amamname> kaptcha.TextProducer.char.length </param-name> <amam-value> </param-value> </it-param> <itel-param> <cription> font arial, courier </description> <amamamname> kaptcha.TextProducer.font.names <////param-value> Courier </param-value> </init-param> <init-param> <cription> tamaño de fuente px. </Description> <amamname> kaptcha.textproducer.font.size </param-name> <param-value> </param-value> </init-param> <init-param> <ription> font color, legal valle: r, r, g, g, b, black, b. </description> <amamname> kaptcha.textproducer.font.color </param-name> <amam-value> negro </amam-value> </init-param> <itin-param> <cription> intervalo de texto </descripción> <amamname> kaptcha.textproducer.char.space </param-name> <amam-value> </param-value> </init-param> <init-param> <Scoltion> Clase de implementación de interferencia </cription> <Param-name> kaptcha.noise.impl </param-name> <param-value> <!-com.google.code.kaptcha.impl.nonoise-> com.google.code.kaptcha.iMppl.defaultnoise </param-valee <Init-Param> <Scuion> Color de interferencia, valor legal: R, G, B o blanco, negro, azul. </description> <amamname> kaptcha.noise.color </param-name> <param-value> negro </amam-value> </it-param> <init-param> <Scuiltion> Image Style: water-stitch com.google.code.kaptcha.imppl.waterripple pheSteyecom.google.kaptcha.impl.fisheyeGOMIMPENT Shadowcom.google.code.kaptcha.impl.shadowgimpy </cription> <Param-name> kaptcha.obscurificator.impl </param-name> <param-value> com.google.code.kaptcha.imppl.waterripple </param-value> </initparam> <initparam> <Scuidtion> <Param-name> kaptcha.background.impl </param-name> <param-value> com.google.code.kaptcha.impl.defaultbackground </param-value> </init-param> <init-param> <Scroduction> Gradiente de color de fondo, inicie el color </descripción> <amamname> kaptcha.background.clear.from </paramname> <Amam-Value> Green </Param-Value> </init-param> <Init-param> <Scuidtion> Gradiente de color de fondo, final de color </cription> <amamname> kaptcha.background.clear.to </param-name> <amam-value> white </param-value> </it-param> <init-param> <Scuidtion> text renderer </scrute> <Param-name> kaptcha.word.Impl </param-name> <param-value> com.google.code.kaptcha.text.imp.defaultwordwordwordererer </amam-value> </ithparam> <itel-param> <Scoltion> La clave clave que almacena el código de verificación en la sesión </descripción> <amamname> kaptcha. <amam-value> kaptcha_session_key </amam-value> </ init-param> <init-param> <Scoltion> La fecha en que se genera kaptcha se coloca en la httpsession. Este es el valor clave para ese elemento en la sesión. </description> <amamname> kaptcha.session.date </param-name> <amam-value> kaptcha_session_date </amam-value> </init-param> </servlet> <ervlet-mapping> <ervlet-name> kaptcha </servlet-name> <uterl-pattern> /randomcode.jpg </url-patter
Llamada frontal: la ruta de la imagen del código de verificación se asigna con randomcode.jpg, y el evento de clic onclick () llama a la función JS. El mismo tiempo en la función JS utiliza la hora actual para invalidar el caché del navegador para actualizar la imagen del código de verificación.
<html> <fead> <meta http-equiv = "content-type" content = "text/html; charset = utf-"> <title> randomCode </title> <script type = "text/javaScript"> function cambiador (nodo) {// usado para generar diferentes códigos de revisificación al hacer clic en node.src = "randomcode.jpg ?jpg? Fecha (). GetTime (); } </script> </head> <body> <img src = "randomcode.jpg" onClick = "cambiante (this)" style = "cursor: pointer;"> <form de action = "check.jsp"> <input type = "text" name = "r"> <input type = "Subt" value = "s"> </form> </body> </html>Check.jsp: obtenga la información de cadena en la imagen del código de verificación a través de (string) session.getAttribute (com.google.code.kaptcha.constants.kaptcha_session_key);
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-"> <title>check</title> </head> <body> <% // Check if it is the correct verification code String k = (String) session .getAttribute(com.google.code.kaptcha.Constants.KAPTCHA_SESSION_KEY); Cadena str = request.getParameter ("r"); if (k.equals (str)) out.print ("verdadero"); out.print (k + "---" + str); %> </body> </html>Leyenda de implementación:
Podemos encontrar que nuestros códigos de verificación se están volviendo cada vez más coloridos, pero todavía estamos en la etapa de verificar solo letras y números en inglés. Entonces, ¿podemos seguir jugando algunos de alta gama? La respuesta es sí. A continuación, echemos un vistazo a cómo implementar códigos de verificación chinos y códigos de verificación aritmética. Todos ellos solo necesitan ser modificados en función del uso anterior de Kaptcha.
Implementación del código de verificación chino:
Primero encontramos un archivo de bytecode de Class, Class, de Class en el paquete kaptcha.jar. Como su nombre indica, es una clase para generar texto en el código de verificación. Podemos implementar una clase heredada de ella por nosotros mismos y usar nuestra propia clase de implementación para hacer el texto en el código de verificación chino a través de la configuración. Después de la siguiente descompilación, podemos ver que se implementa de esa manera. La función getText () se usa para generar el texto del código de verificación que renderizará el configurador getConfig (), por lo que solo necesitamos heredar la clase de configuración e implementar la interfaz de generación de texto y sobrescribir el método getText ().
public class DefaultTextCreator extiende implementos configurables TextProducer {public String getText () {int longitud = getConfig (). GetTextProDucerCharlength (); char [] chars = getConfig (). getTextProDucCarRtring (); int randomContext = chars.length -; Rand aleatorio = new Random (); StringBuffer text = new StringBuffer (); for (int i =; i <longitud; i ++) {text.append (chars [(rand.nextint (randomContext)+)]); } return text.ToString (); }}La siguiente es la implementación específica de chinesetext.java: el programa solo ejecuta el código en getText (). El código original está escrito en getText1 () y no lo ejecuta. Puedes hacer una comparación.
Public Class ChinesExtext extiende implementos configurables TextProducer {public String getText () {int longitud = getConfig (). getTextProDucCarLengthing (); // char [] chars = getConfig (). GetTextProDucCarRing (); Cadena [] s = nueva cadena [] {"I", "Amor", "Tab", "Trow" y "," vender "," tornillo "," botón "}; rand rand = new Random (); StringBuffer sb = new StringBuffer (); for (int i =; i <longitud; i ++) {int ind = rand.nextint (s.lent longitud SB.ToString (); "", "," a "," b "," c "," d "," e "," f "}; Rand aleatorio = new Random (); for (int i =; i <longitud; i ++) {switch (rand.nextint (array.length)) {case: tempint = rand.nextInt ()+; FirstWord = String.ValueOf ((Char) Tempint); romper; Caso: int r, r, r, r; Cadena strh, strl; // high & low r = rand.nextint () +; // Cerrar front y abrir [,) if (r ==) {r = rand.nextInt (); } else {r = rand.nextInt (); } r = rand.nextInt () +; if (r ==) {r = rand.nextint () +; } else if (r ==) {r = rand.nextInt (); } else {r = rand.nextInt (); } strh = array [r] + array [r]; strl = array [r] + array [r]; byte [] bytes = new byte []; bytes [] = (byte) (integer.parseInt (strh,)); bytes [] = (byte) (integer.parseInt (strl,)); FirstWord = new String (bytes); romper; predeterminado: tempint = rand.nextint () +; FirstWord = String.ValueOf ((Char) Tempint); romper; } Finalword += FirstWord; } return Finalword; }}El último paso es cambiar el valor de la clase de implementación de texto en Web.xml, de modo que el componente llame a la clase que escribe para generar el código de verificación chino.
<Init-param> <Scuion> Clase de implementación de texto </cription> <Param-name> kaptcha.textproducer.impl </param-name> <amam-value> chinesetext </param-value> </init-param>
Leyenda de implementación:
Implementación del código de verificación de operación aritmética:
Lo mismo que el código de verificación chino anterior, necesitamos implementar nuestra propia clase heredando clases e interfaces, y reescribir las funciones en él, y luego cambiar la información de configuración para que los componentes llamen a las clases que implementan para lograr la diversificación del formulario del código de verificación.
El código del archivo bytecode kaptchaservlet es el siguiente:
clase pública Kaptchaservlet extiende httpservlet implementa servlet {private propiedades props = new Properties (); productor privado kaptchaproducer = null; String private SessionKeyValue = null; public void init (servletconfig conf) lanza ServletException {super.init (conf); ImageIO.SetUsecache (falso); Enumeration <?> InitParams = conf.getInitParamTernames (); while (initParams.hasmoreElements ()) {string key = (string) initParams.nextelement (); Valor de cadena = conf.getInitParameter (clave); this.props.put (clave, valor); } Config config = new config (this.props); this.kaptChaproDucer = config.getProDucerImpl (); this.SessionKeyValue = config.getSessionKey (); } public void doget (httpservletRequest req, httpservletResponse resp) lanza ServletException, ioexception {resp.setDateHeader ("expires", l); resp.setheader ("Cache-Control", "No-store, no-cache, debe revalidar"); resp.AddHeader ("Cache-Control", "Post-Check =, pre-check ="); resp.setheader ("Pragma", "No-Cache"); resp.setContentType ("Image/jpeg"); String Captext = this.kaptChaproDucer.createText (); req.getSession (). SetAttribute (this.SessionKeyValue, Captext); BufferedImage bi = this.kaptchaproducer.createImage (captext); ServletOutputStream out = resp.getOutputStream (); Imageio.write (bi, "jpg", out); intente {out.flush (); } finalmente {out.close (); }}}Luego, el código kaptchaservlet.java que implementé por mí mismo es el siguiente: Se agregó la lógica al archivo de bytecode original para implementar el código de verificación de adición, y puede descubrirlo a través de la comparación.
clase pública Kaptchaservlet extiende httpservlet implementa servlet {props de propiedades privadas; productor privado Kaptchaproducer; Session KeyValue de cadena privada; public kaptchaservlet () {this.props = new Properties (); this.kaptchaproducer = null; this.sessionKeyValue = null; } public void init (servletConfig conf) lanza ServletException {super.init (conf); ImageIO.SetUsecache (falso); Enumeration InitParams = conf.getInitParamTernames (); while (initParams.hasmoreElements ()) {string key = (string) initParams.nextelement (); Valor de cadena = conf.getInitParameter (clave); this.props.put (clave, valor); } Config config = new config (this.props); this.kaptChaproDucer = config.getProDucerImpl (); this.SessionKeyValue = config.getSessionKey (); } public void doget (httpservletRequest req, httpservletResponse resp) lanza ServletException, ioexception {resp.setDateHeader ("expires", l); resp.setheader ("Cache-Control", "No-store, no-cache, debe revalidar"); resp.AddHeader ("Cache-Control", "Post-Check =, pre-check ="); resp.setheader ("Pragma", "No-Cache"); resp.setContentType ("Image/jpeg"); String Captext = this.kaptChaproDucer.createText (); Cadena s = captext.substring (,); Cadena s = captext.substring (,); int r = integer.valueOf (s) .intValue () + integer.valueOf (s) .intvalue (); req.getSession (). SetAttribute (this.SessionKeyValue, String.ValueOf (R)); BufferedImage bi = this.kaptchaproducer.createImage (s+"+"+s+"=?"); ServletOutputStream out = resp.getOutputStream (); Imageio.write (bi, "jpg", out); intente {out.flush (); } finalmente {out.close (); }}}También debemos cambiar la configuración al comienzo de Web.xml para que el componente llame al servlet que implementó:
<Servlet-Name> Kaptcha </Servlet-Name> <Servlet-Class> Kaptchaservlet </Servlet-Class>
Leyenda de implementación:
Resumir:
Esta es solo una simple implementación del código de verificación, pero aún está lejos de usarlo para proyectos comerciales. Si el código de verificación no está descifrado, se deben agregar varios algoritmos de cifrado. Aun así, puede buscar el código de verificación agrietado en todas partes. Hay una base de datos subterránea en Internet, que almacena nuestra información personal. La información se resuelve uno por uno, lo cual es muy terrible. Sin embargo, dicha base de datos existe objetivamente. Los códigos de verificación, como parte importante de la protección de las contraseñas de la cuenta, se han vuelto cada vez más inseguros. Debido a la fuga de información personal, otros pueden cometer fraude en usted después de que tengan suficiente información sobre usted. Entre ellos, los códigos de verificación son una parte importante. Recientemente, se engañó a un graduado para obtener códigos de verificación y toda su riqueza se transfirió en unas pocas horas. Por lo tanto, proteja su código de verificación y no lo revele fácilmente a los demás.
Por supuesto, no nos quedaremos quietos y esperaremos la muerte. Los tipos actuales de códigos de verificación se están volviendo cada vez más difíciles de descifrar. Como el reconocimiento de voz y el reconocimiento facial son familiares, por lo que no diré mucho.
Aquí presentamos un "nuevo" concepto de código de verificación: autenticación de dos factores.
La autenticación de dos factores es un sistema que utiliza la tecnología de sincronización de tiempo, que utiliza una contraseña única generada en función de las tres variables de tiempo, evento y clave para reemplazar la contraseña estática tradicional. Cada tarjeta de contraseña dinámica tiene una clave única, que se almacena en el lado del servidor al mismo tiempo. Cada vez que la tarjeta de contraseña dinámica y el servidor calculan la contraseña dinámica autenticada en función de la misma clave, los mismos parámetros aleatorios (tiempo, evento) y el mismo algoritmo, asegurando así la consistencia de la contraseña y la realización de la autenticación del usuario. Debido a que los parámetros aleatorios son diferentes durante cada autenticación, la contraseña dinámica generada cada vez también es diferente. Debido a que la aleatoriedad de los parámetros durante cada cálculo garantiza la imprevisibilidad de cada contraseña, el proceso de autenticación de contraseña más básico garantiza la seguridad del sistema. Resuelva pérdidas importantes causadas por el fraude de contraseñas, evita intrusos maliciosos o daños artificiales, y resuelva el problema de intrusión causado por la fuga de contraseña.
En pocas palabras, la autenticación de identidad de dos factores es un sistema de autenticación de identidad que solo puede funcionar a través de la combinación de lo que sabe y los dos elementos que puede tener. Por ejemplo, una tarjeta bancaria que retira dinero de un cajero automático es un ejemplo de un mecanismo de autenticación de dos factores. Debe conocer la combinación de la contraseña de retiro y la tarjeta bancaria antes de poder usarla. Actualmente, el sistema de autenticación principal de dos factores se basa en la sincronización del tiempo y tiene una alta participación de mercado. El sistema de autenticación de dos factores DKEY , el sistema de autenticación de dos factores RSA , etc. Dado que DKEY aumenta el soporte para la autenticación de contraseña de SMS y la autenticación híbrida SMS + token, el sistema de autenticación de dos factores DKEY es más competitivo que RSA.
Lo anterior es el contenido relevante de la producción del código de verificación Java presentada por el editor. ¡Espero que te sea útil!