Em seguida, o artigo anterior da Java Verification Code Production (Parte 1) apresentará o conhecimento relevante sobre o código de verificação de Java!
Método 3:
Implementado com o componente de código aberto jcaptcha, combinado com o Spring, ele pode gerar várias formas de códigos de verificação. O JCAPTCHA é a versão Java do projeto Captcha. É um projeto de código aberto que suporta a geração de códigos de verificação para gráficos e versões de som. Ao gerar códigos de verificação para versões sonoras, é necessário Freetts. O nome completo de Captcha é um teste público de Turing completamente automatizado para informar computadores e humanos separados como um projeto de pesquisa científica na Universidade Carnegie Mellon. Foi usado para gerar um teste fácil para os seres humanos passarem, mas difíceis para os computadores passarem. Atualmente, é amplamente utilizado em aplicativos de rede e é usado para impedir que os robôs publiquem informações de spam. Atualmente, o site oficial do JCAPTCHA mostra que existe a versão 2.0, mas a versão binária é apenas a versão 1.0 para download.
Primeiro, precisamos preparar o pacote JAR correspondente
Na implementação do projeto JCAPTCHA, ele também faz referência a dois projetos de código aberto, comuns-colecionamentos e comuns. Além disso, a implementação do próprio JCaptcha, precisamos de três pacotes no total, e as informações específicas são as seguintes:
jcaptcha-2.0-all.jarcommons-logging-1.1.1.jarcommons-collections-3.2.jar
Em segundo lugar, vejamos as informações de configuração de chave no web.xml abaixo: Além de configurar o caminho de classe específico do componente jcaptcha, o SubmitactionsServlet também está configurado, que é usado como servlet para códigos de verificação de comparação e ambos são mapeados. Pode ser entendido como alterando o nome. Ao chamar o componente ou servlet em /jcaptcha.jpg e /submit.action, respectivamente, ele pode ser usado diretamente para usar esse nome de mapeamento.
<Verlet> <Verlet-name> jcaptcha </ervlet-name> <Servlet-class> com.octo.captcha.module.servlet.image.simpleimagecaptchaservlet </servlet-class> </servlet> <ervlet> <ervlet-name> submit </ervlet-Name> <Verlet-class> com.octo.captcha.module.servlet.image.sample.subMitactionservlet </servlet-class> </servlet> <Verlet-Mapping> <ervlet-name> jcaptcha </-name> <url-patttern>/jateppchapcha </url-Pnattern>/jatepchapcha </url-Pnattern> <Verlet-name> Envie </ervlet-name> <url-tattern> /submit.action </url-tattern> </servlet-mapping>
web.xml
Em seguida, vamos ver como o SubmitactionServlet é implementado: como o pacote de componentes jcaptcha é importado, o método encapsulado SimpleImageCaptChaservlet.ValidaterSponse (Solicitação, UserCaptCaresponse) é diretamente chamado para determinar se as informações no código de verificação correspondem ao envio, sem considerar o processo de implementação específico.
classe pública SubmitactionsServlet estende o httpServlet {Protected void DoPost (solicitação HttPervletRequest, resposta httpServletResponse) lança servletexception, ioexception {string userCaptCharSponse = request.getParameter ("japtcha"); Boolean CaptChapassed = SimpleImageCaptChaservlet.ValidaterSponse (Solicitação, UserCaptCharSponse); if (CAPTCHAPASSED) Response.getWriter (). Write ("Captcha passou"); else {Response.getWriter (). Write ("Captcha falhou"); } resposta.getWriter (). write ("<br/> <a href = 'index.jsp'> tente novamente </a>"); }} SubtactionsServlet Finalmente, vamos dar uma olhada na simples chamada de recepção:
<html> <body> <h> amostra simples de servlet captcha </h> <formulário action = "submit.action" method = "post"> <img src = "jcaptcha.jpg"/> <input type = "text" name = "japtcha" = ""/> <input Type = "subt"/> <form "</forma"
Legenda da implementação:
Método 4:
Implementado com o componente de código aberto kaptcha. Também o uso do Kaptcha requer o download do seu pacote de componentes JAR. O Kaptcha é uma ferramenta de geração de código de verificação muito prática. Com ele, você pode gerar códigos de verificação de vários estilos, porque é configurável. O princípio da Kaptcha Works é chamar com.google.code.kaptcha.servlet.kaptchaservlet (pode -se ver que é um projeto de código aberto do Google) para gerar uma imagem. Ao mesmo tempo, coloque a sequência de código de verificação gerada em HTTPSession.
Use Kaptcha para configurá -lo convenientemente:
Código de verificação Código de verificação do tamanho da fonte Código de verificação do tamanho da fonte Código de verificação da cor da fonte Faixa de conteúdo (número, letra, caracteres chineses!) com.google.code.kaptcha.gimpyengine estilo personalizado)
...
As informações de configuração do Kaptcha também são colocadas em web.xml: as informações de configuração inicializadas na tag <iit-param>.
<Verlet> <Verlet-name> kaptcha </servlet-name> <Servlet-class> com.google.code.kaptcha.servlet.kaptchaservlet </servlet-class> <iit-param> <lameM> borda da imagem, valor legal: sim, não </cription> <a Paramval> kaptcha.border </paramn-name </paramn-name </irtUer> <init-param> <cription> cor de borda, valor legal: r, g, b (e alfa opcional) ou branco, preto, azul. </Descrição> <amam-name> kaptcha.border.color </amam-name> <amam-value> preto </amam-value> </irit-param> <iit-param> <iit-param> <cription> espessura da borda, valor jurídico:>/descrição> <amaM-name> kappcha.border.thickness </param-name> <iit-param> <iit-param> <cription> largura da imagem </cription> <amam-name> kaptcha.image.width </param-name> <amam-value> </param-value </init-param> <iot-param> <crection> imagem </descrição <amam-name> kaptcha.image.hester.hearm> </init-param> <iit-param> <cription> Classe de implementação da imagem </cription> <amam-name> kaptcha.producer.impl </param-name> <amam-value> com.google.code.kaptcha.impl.defaultkaptcha </param-value> </init-param> <amam-name> kaptcha.textproducer.impl </param-name> <amam-value> com.google.code.kaptcha.text.impl.defaultTextCreator </amam-value> </i init-param> </crelection> </crelection> A descrição da coleta de textos, o valor da verificação é obtido a partir desta coleção </lort> </lort> </lort> </lortTextCerator> </amification-value> </init-param> </crelection> </crelection> Coleção de textos, o valor da verificação é obtido a partir desta coleção </lort> </10) </init-param> <amam-name> kaptcha.textProducer.char.string </param-name> <amam-value> </param-value> <!-<amam-value> abcdegfynmnpwx </param-value>-> <!-<am-value> mooch.com Código de verificação init </Value>-> <! length</description> <param-name>kaptcha.textproducer.char.length</param-name> <param-value></param-value> </init-param> <init-param> <description>Font Arial, Courier</description> <param-name>kaptcha.textproducer.font.names</param-name> <param-value>Arial, Courier</param-value> </init-param> <iit-param> <cription> Tamanho da fonte px. </Descrição> <amam-name> kaptcha.textproducer.font.color </param-name> <amam-value> preto </amam-value> </irit--param> <iot--param> <cchart> intervalo de texto </descrição> <amam-name> kaptcha.TextProduCer.Char.Char.Char. </parampace </param-name> kaptcha.textproduCer.Char.Char. </parampac <iit-param> <cription> Classe de implementação de interferência </cription> <amam-name> kaptcha.noise.impl </param-name> <amam-value> <!-com.google.code.kaptcha.impl.noise-> com.google.kaptcha.impl.defaultNeise-> com.google.kaptcha.impl.defaultNeise- Cor, valor legal: r, g, b ou branco, preto, azul. </Descrição> <amam-name> kaptcha.noise.color </param-name> <amam-value> preto </amam-value> </irit-param> <iit-param> <cription> Estilo de imagem: water-titch com.google.code.kaptcha.impl.waterripple fisheyeyecom.google.kapt.kaptchatchaptcha.impl.impl.watersplel fisheyeyecom.google.kapt.kapt.kaptchaptchapyympl.implypl.wateryeyecom.google.kapt.kapt.kaptchatchaptcha.impl.implypl. ShadowCom.google.code.kaptcha.impl.shadowgimpy </cription> <amam-name> kaptcha.obscurificator.impl </amam-name> <amam-value> com.google.code.kaptcha.impl.waterripple </param-value> </init-param >----Param> <amam-name> kaptcha.background.impl </param-name> <amam-value> com.google.code.kaptcha.impl.defaultbackground </param-value> </irit-param> <itcharam> <crection> cor de fundo, cor </description> </paramname> kaptcha.back.black.clom.Clack.Clack.Clack.Clack.Clack.Clack.Clack.ClorM.Clorde. <amam-value> verde </amam-value> </irit-param> <oti init-param> <cription> gradiente de cor, cor final </cription> <amam-name> kaptcha.background.clear.to </amam-name> <amam-value> white </am param-value> <//inot-Param> <iniM-Param> <amam-name> kaptcha.word.impl </param-name> <amam-value> com.google.code.kaptcha.text.impl.defaultwordrenderer </param-value> </init-param> init-param> <cription> a chave que armazena o código de verificação na sessão </descrição> <amam-value> kaptcha_session_key </param-value> </irit--param> <it-param> <cription> A data em que o kaptcha é gerado é colocado na httpssession. Este é o valor chave para esse item na sessão. </Descrição> <amam-name> kaptcha.session.date </amam-name> <amam-value> kaptcha_session_date </amam-value> </irit-param> </servlet> <url-patping> <ervlet-name> kaptcha </servlet> <url-patn-stetn> /randomcode.name>
Chamada frontal: O caminho da imagem do código de verificação é mapeado com randomcode.jpg, e o evento de clique onclick () chama a função JS. Ao mesmo tempo na função JS, usa o tempo atual para invalidar o cache do navegador para atualizar a imagem do código de verificação.
<html> <head> <meta http-equiv = "content-type" content = "text/html; charset = utf-"> <title> RandomCode </title> <script type = "text/javaScript"> function Changer (node) {// usado para gerar diferentes códigos de verificação quando clicar n.s. Date (). Gettime (); } </script> </ad Head> <body> <img src = "randomcode.jpg" onclick = "Changer (this)" style = "cursor: pointer;"> <formulário action = "check.jsp"> <input type = "text" name = "r"> <input Type = "subit" value = ">"> "> <form>Check.jsp: Obtenha as informações da string na imagem do código de verificação através (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); String str = request.getParameter ("r"); if (k.Equals (str)) out.print ("true"); out.print (k + "---" + str); %> </body> </html>Legenda da implementação:
Podemos descobrir que nossos códigos de verificação estão se tornando cada vez mais coloridos, mas ainda estamos no estágio de verificar apenas letras e números em inglês. Então, ainda podemos jogar alguns de ponta? A resposta é sim. Em seguida, vamos dar uma olhada em como implementar códigos de verificação chineses e códigos de verificação aritmética. Todos eles só precisam ser modificados com base no uso acima do kaptcha.
Implementação do código de verificação chinês:
Primeiro, encontramos um arquivo bytecode DefaultTextCreator.class no pacote kaptcha.jar. Como o nome sugere, é uma classe para gerar texto no código de verificação. Podemos implementar uma classe herdada por nós mesmos e usar nossa própria classe de implementação para tornar o texto no código de verificação chinês por meio da configuração. Após a descomposição seguinte, podemos ver que ela é implementada dessa maneira. A função getText () é usada para gerar o texto do código de verificação que o configurador getConfig () renderizará, por isso precisamos apenas herdar a classe de configuração e implementar a interface de geração de texto e substituir o método getText ().
classe pública DefaultTextCreator estende implementos configuráveis textProducer {public string getText () {int length = getConfig (). getTextProducerCharLength (); char [] chars = getConfig (). getTextProduCercharString (); int Randomcontext = chars.length -; Rand aleatório = novo aleatório (); StringBuffer text = new StringBuffer (); for (int i =; i <comprimento; i ++) {text.append (chars [(rand.nextInt (randomcontext)+)]); } retornar text.toString (); }}A seguir, é apresentada a implementação específica do chineseText.java: o programa executa apenas o código em getText (). O código original é escrito em getText1 () e não o executa. Você pode fazer uma comparação.
classe pública chinesetext estende implementos configuráveis textProducer {public string getText () {int length = getConfig (). getTextProduCerCherLength (); // char [] chars = getConfig (). getTextProduCercharString (); String [] s = new String [] {"i", "Love", "Tab", "Trow" e "," Sell "," Screw "," Button "}; Rand Rand = new Random (); StringBuffer sb = new StringBuffer (); para (int i =; i <i <length; i ++) {int ind = Rand.NeXTINT (S. SB.ToString (); "", "," A "," B "," C "," D "," E "," F "}; Rand aleatório = novo aleatório (); for (int i =; i <comprimento; i ++) {switch (rand.nextInt (array.length)) {case: tempint = rand.nextint ()+; FirstWord = String.ValueOf ((char) tempint); quebrar; Caso: int r, r, r, r; String strh, strl; // alto e baixo r = rand.nextInt () +; // feche a frente e abra [,) 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 = matriz [r] + matriz [r]; byte [] bytes = novo byte []; bytes [] = (byte) (Integer.parseint (strh,)); bytes [] = (byte) (Integer.parseint (strl,)); Firstword = new String (bytes); quebrar; padrão: tempint = rand.nextInt () +; FirstWord = String.ValueOf ((char) tempint); quebrar; } Finalword += Firstword; } retornar Finalword; }}A última etapa é alterar o valor da classe de implementação de texto no web.xml, para que o componente chame a classe que grava para gerar código de verificação chinês.
<iit-param> <cription> Classe de implementação de texto </cription> <amam-name> kaptcha.textproducer.impl </param-name> <amam-value> chinesetext </amam-value> </init-param>
Legenda da implementação:
Implementação do código de verificação da operação aritmética:
O mesmo que o código de verificação chinês acima, precisamos implementar nossa própria classe, herdando classes e interfaces e reescrever as funções nela e alterar as informações de configuração para fazer com que os componentes chamem as classes que eles implementam para obter diversificação do formulário do código de verificação.
O código do arquivo KaptChaservlet Bytecode é o seguinte:
A classe pública KaptChaservlet estende o httpServlet implementa o servlet {private Properties Props = new Properties (); produtor privado kaptchaproduces = null; private string sessionKeyValue = null; public void init (servletconfig conf) lança servletexception {super.init (conf); Imageio.setUseCache (false); Enumeração <?> InitParams = conf.getInitParameterNames (); while (initParams.hasMoreElements ()) {String key = (String) initParams.NextElement (); String value = conf.getInitParameter (chave); this.props.put (chave, valor); } Config config = new config (this.props); this.kaptchaproduces = config.getProducerImpl (); this.sessionKeyValue = config.getSessionKey (); } public void Doget (httpServletRequest req, httpServletResponse resp) lança servletexception, ioexception {resp.setDateHeader ("expira", l); resp.setheader ("Controle de cache", "sem lojas, sem cache, não-revalidado"); resp.addHeader ("Controle de cache", "pós-check =, pré-check ="); resp.setheader ("Pragma", "sem cache"); resp.SetContentType ("Image/jpeg"); String captext = this.kaptchaproduces.createText (); req.getSession (). SetAttribute (this.sessionKeyValue, captext); BufedImage bi = this.kaptchaproduces.createImage (captext); ServletOutputStream out = resp.getOutputStream (); Imageio.write (bi, "jpg", out); tente {out.flush (); } finalmente {out.close (); }}}Em seguida, o código KaptChaservlet.java que implementei por mim é o seguinte: Adicionado lógica ao arquivo bytecode original para implementar o código de verificação de adição e você pode descobri -lo através da comparação.
A classe pública KaptChaservlet estende o httpServlet implementa o servlet {Propriedades privadas adereços; produtor privado Kaptchaproduces; Private String sessionKeyValue; public KaptChaservlet () {this.Props = new Properties (); this.kaptchaproduces = null; this.sessionKeyValue = null; } public void init (servletconfig conf) lança servletexception {super.init (conf); Imageio.setUseCache (false); Enumeração initparams = conf.getInitParameterNames (); while (initParams.hasMoreElements ()) {String key = (String) initParams.NextElement (); String value = conf.getInitParameter (chave); this.props.put (chave, valor); } Config config = new config (this.props); this.kaptchaproduces = config.getProducerImpl (); this.sessionKeyValue = config.getSessionKey (); } public void Doget (httpServletRequest req, httpServletResponse resp) lança servletexception, ioexception {resp.setDateHeader ("expira", l); resp.setheader ("Controle de cache", "sem lojas, sem cache, não-revalidado"); resp.addHeader ("Controle de cache", "pós-check =, pré-check ="); resp.setheader ("Pragma", "sem cache"); resp.SetContentType ("Image/jpeg"); String captext = this.kaptchaproduces.createText (); String s = captext.substring (,); String s = captext.substring (,); int r = inteiro.ValueOf (s) .IntValue () + Integer.ValueOf (s) .IntValue (); req.getSession (). setAttribute (this.sessionKeyValue, string.valueof (r)); BufferImage bi = this.kaptchaproduces.createImage (s+"+"+s+"=?"); ServletOutputStream out = resp.getOutputStream (); Imageio.write (bi, "jpg", out); tente {out.flush (); } finalmente {out.close (); }}}Também precisamos alterar a configuração no início do web.xml para fazer o componente chamar o servlet que você implementou:
<Verlet-name> kaptcha </vletname> <Servlet-Class> KaptChaservlet </Servlet-Class>
Legenda da implementação:
Resumir:
Esta é apenas uma implementação simples do código de verificação, mas ainda está longe de usá -lo para projetos comerciais. Se o código de verificação não estiver rachado, vários algoritmos de criptografia devem ser adicionados. Mesmo assim, você pode procurar o código de verificação rachado em todos os lugares. Há um banco de dados subterrâneo na internet, que armazena nossas informações pessoais. A informação é resolvida uma a uma, o que é muito terrível. No entanto, esse banco de dados existe objetivamente. Os códigos de verificação, como parte importante da proteção das senhas da conta, tornaram -se cada vez mais inseguros. Devido ao vazamento de informações pessoais, outras pessoas podem cometer fraude em você depois que elas têm informações suficientes sobre você. Entre eles, os códigos de verificação são uma parte importante. Recentemente, um graduado foi enganado para obter códigos de verificação e toda a sua riqueza foi transferida dentro de poucas horas. Portanto, proteja seu código de verificação e não o divulgue facilmente a outras pessoas.
Claro, não ficaremos parados e esperaremos pela morte. Os tipos atuais de códigos de verificação estão se tornando cada vez mais difíceis de quebrar. Como reconhecimento de voz e reconhecimento facial, todos são familiares, então não vou dizer muito.
Aqui, introduzimos um "novo" Código de Verificação de Verificação: Autenticação de dois fatores.
A autenticação de dois fatores é um sistema que usa a tecnologia de sincronização de tempo, que usa uma senha única gerada com base nas três variáveis de tempo, evento e chave para substituir a senha estática tradicional. Cada cartão de senha dinâmica possui uma chave exclusiva, que é armazenada no lado do servidor ao mesmo tempo. Cada vez que o cartão de senha dinâmica e o servidor calculam a senha dinâmica autenticada com base na mesma chave, nos mesmos parâmetros aleatórios (tempo, evento) e no mesmo algoritmo, garantindo assim a consistência da senha e realizando a autenticação do usuário. Como os parâmetros aleatórios são diferentes durante cada autenticação, a senha dinâmica gerada cada vez também é diferente. Como a aleatoriedade dos parâmetros durante cada cálculo garante a imprevisibilidade de cada senha, o processo de autenticação de senha mais básico garante a segurança do sistema. Resolva grandes perdas causadas por fraude de senha, impedir intrusos maliciosos ou danos artificiais e resolver o problema de intrusão causado pelo vazamento de senha.
Simplificando, a autenticação de identidade de dois fatores é um sistema de autenticação de identidade que só pode funcionar com a combinação do que você sabe e dos dois elementos que pode ter. Por exemplo, um cartão bancário retirando dinheiro de um caixa eletrônico é um exemplo de um mecanismo de autenticação de dois fatores. Você precisa conhecer a combinação da senha de retirada e do cartão bancário antes de poder usá -lo. Atualmente, o sistema de autenticação de dois fatores é baseado na sincronização do tempo e possui uma alta participação de mercado. O sistema de autenticação de dois fatores do DKEY , sistema de autenticação de dois fatores RSA , etc. Como o DKEY aumenta o suporte para a autenticação de senha SMS e a autenticação híbrida SMS + token, o sistema de autenticação de dois fatores do DKEY é mais competitivo que o RSA.
O exposto acima é o conteúdo relevante da produção de código de verificação de Java introduzida pelo editor. Espero que seja útil para você!