elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


  Mostrar Mensajes
Páginas: 1 ... 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 [119] 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 ... 456
1181  Programación / Programación C/C++ / Re: Quitar acentos de un string en: 10 Julio 2015, 19:55 pm
Ahhh es para formatear urls amigables, entonces dale un vistazo a esto:

https://github.com/WordPress/WordPress/blob/master/wp-includes/formatting.php#LC968

Te servirá para crear reglas similares en c++, está hecho en php y es la función nativa de Wordpress para crear las urls amigables:

Código
  1. function remove_accents( $string ) {
  2. if ( !preg_match('/[\x80-\xff]/', $string) )
  3. return $string;
  4. if (seems_utf8($string)) {
  5. $chars = array(
  6. // Decompositions for Latin-1 Supplement
  7. chr(194).chr(170) => 'a', chr(194).chr(186) => 'o',
  8. chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
  9. chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
  10. chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
  11. chr(195).chr(134) => 'AE',chr(195).chr(135) => 'C',
  12. chr(195).chr(136) => 'E', chr(195).chr(137) => 'E',
  13. chr(195).chr(138) => 'E', chr(195).chr(139) => 'E',
  14. chr(195).chr(140) => 'I', chr(195).chr(141) => 'I',
  15. chr(195).chr(142) => 'I', chr(195).chr(143) => 'I',
  16. chr(195).chr(144) => 'D', chr(195).chr(145) => 'N',
  17. chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
  18. chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
  19. chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
  20. chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
  21. chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
  22. chr(195).chr(158) => 'TH',chr(195).chr(159) => 's',
  23. chr(195).chr(160) => 'a', chr(195).chr(161) => 'a',
  24. chr(195).chr(162) => 'a', chr(195).chr(163) => 'a',
  25. chr(195).chr(164) => 'a', chr(195).chr(165) => 'a',
  26. chr(195).chr(166) => 'ae',chr(195).chr(167) => 'c',
  27. chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
  28. chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
  29. chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
  30. chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
  31. chr(195).chr(176) => 'd', chr(195).chr(177) => 'n',
  32. chr(195).chr(178) => 'o', chr(195).chr(179) => 'o',
  33. chr(195).chr(180) => 'o', chr(195).chr(181) => 'o',
  34. chr(195).chr(182) => 'o', chr(195).chr(184) => 'o',
  35. chr(195).chr(185) => 'u', chr(195).chr(186) => 'u',
  36. chr(195).chr(187) => 'u', chr(195).chr(188) => 'u',
  37. chr(195).chr(189) => 'y', chr(195).chr(190) => 'th',
  38. chr(195).chr(191) => 'y', chr(195).chr(152) => 'O',
  39. // Decompositions for Latin Extended-A
  40. chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
  41. chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
  42. chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
  43. chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
  44. chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
  45. chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
  46. chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
  47. chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
  48. chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
  49. chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
  50. chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
  51. chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
  52. chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
  53. chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
  54. chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
  55. chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
  56. chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
  57. chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
  58. chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
  59. chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
  60. chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
  61. chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
  62. chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
  63. chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
  64. chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
  65. chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
  66. chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
  67. chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
  68. chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
  69. chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
  70. chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
  71. chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
  72. chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
  73. chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
  74. chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
  75. chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
  76. chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
  77. chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
  78. chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
  79. chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
  80. chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
  81. chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
  82. chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
  83. chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
  84. chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
  85. chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
  86. chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
  87. chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
  88. chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
  89. chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
  90. chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
  91. chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
  92. chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
  93. chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
  94. chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
  95. chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
  96. chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
  97. chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
  98. chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
  99. chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
  100. chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
  101. chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
  102. chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
  103. chr(197).chr(190) => 'z', chr(197).chr(191) => 's',
  104. // Decompositions for Latin Extended-B
  105. chr(200).chr(152) => 'S', chr(200).chr(153) => 's',
  106. chr(200).chr(154) => 'T', chr(200).chr(155) => 't',
  107. // Euro Sign
  108. chr(226).chr(130).chr(172) => 'E',
  109. // GBP (Pound) Sign
  110. chr(194).chr(163) => '',
  111. // Vowels with diacritic (Vietnamese)
  112. // unmarked
  113. chr(198).chr(160) => 'O', chr(198).chr(161) => 'o',
  114. chr(198).chr(175) => 'U', chr(198).chr(176) => 'u',
  115. // grave accent
  116. chr(225).chr(186).chr(166) => 'A', chr(225).chr(186).chr(167) => 'a',
  117. chr(225).chr(186).chr(176) => 'A', chr(225).chr(186).chr(177) => 'a',
  118. chr(225).chr(187).chr(128) => 'E', chr(225).chr(187).chr(129) => 'e',
  119. chr(225).chr(187).chr(146) => 'O', chr(225).chr(187).chr(147) => 'o',
  120. chr(225).chr(187).chr(156) => 'O', chr(225).chr(187).chr(157) => 'o',
  121. chr(225).chr(187).chr(170) => 'U', chr(225).chr(187).chr(171) => 'u',
  122. chr(225).chr(187).chr(178) => 'Y', chr(225).chr(187).chr(179) => 'y',
  123. // hook
  124. chr(225).chr(186).chr(162) => 'A', chr(225).chr(186).chr(163) => 'a',
  125. chr(225).chr(186).chr(168) => 'A', chr(225).chr(186).chr(169) => 'a',
  126. chr(225).chr(186).chr(178) => 'A', chr(225).chr(186).chr(179) => 'a',
  127. chr(225).chr(186).chr(186) => 'E', chr(225).chr(186).chr(187) => 'e',
  128. chr(225).chr(187).chr(130) => 'E', chr(225).chr(187).chr(131) => 'e',
  129. chr(225).chr(187).chr(136) => 'I', chr(225).chr(187).chr(137) => 'i',
  130. chr(225).chr(187).chr(142) => 'O', chr(225).chr(187).chr(143) => 'o',
  131. chr(225).chr(187).chr(148) => 'O', chr(225).chr(187).chr(149) => 'o',
  132. chr(225).chr(187).chr(158) => 'O', chr(225).chr(187).chr(159) => 'o',
  133. chr(225).chr(187).chr(166) => 'U', chr(225).chr(187).chr(167) => 'u',
  134. chr(225).chr(187).chr(172) => 'U', chr(225).chr(187).chr(173) => 'u',
  135. chr(225).chr(187).chr(182) => 'Y', chr(225).chr(187).chr(183) => 'y',
  136. // tilde
  137. chr(225).chr(186).chr(170) => 'A', chr(225).chr(186).chr(171) => 'a',
  138. chr(225).chr(186).chr(180) => 'A', chr(225).chr(186).chr(181) => 'a',
  139. chr(225).chr(186).chr(188) => 'E', chr(225).chr(186).chr(189) => 'e',
  140. chr(225).chr(187).chr(132) => 'E', chr(225).chr(187).chr(133) => 'e',
  141. chr(225).chr(187).chr(150) => 'O', chr(225).chr(187).chr(151) => 'o',
  142. chr(225).chr(187).chr(160) => 'O', chr(225).chr(187).chr(161) => 'o',
  143. chr(225).chr(187).chr(174) => 'U', chr(225).chr(187).chr(175) => 'u',
  144. chr(225).chr(187).chr(184) => 'Y', chr(225).chr(187).chr(185) => 'y',
  145. // acute accent
  146. chr(225).chr(186).chr(164) => 'A', chr(225).chr(186).chr(165) => 'a',
  147. chr(225).chr(186).chr(174) => 'A', chr(225).chr(186).chr(175) => 'a',
  148. chr(225).chr(186).chr(190) => 'E', chr(225).chr(186).chr(191) => 'e',
  149. chr(225).chr(187).chr(144) => 'O', chr(225).chr(187).chr(145) => 'o',
  150. chr(225).chr(187).chr(154) => 'O', chr(225).chr(187).chr(155) => 'o',
  151. chr(225).chr(187).chr(168) => 'U', chr(225).chr(187).chr(169) => 'u',
  152. // dot below
  153. chr(225).chr(186).chr(160) => 'A', chr(225).chr(186).chr(161) => 'a',
  154. chr(225).chr(186).chr(172) => 'A', chr(225).chr(186).chr(173) => 'a',
  155. chr(225).chr(186).chr(182) => 'A', chr(225).chr(186).chr(183) => 'a',
  156. chr(225).chr(186).chr(184) => 'E', chr(225).chr(186).chr(185) => 'e',
  157. chr(225).chr(187).chr(134) => 'E', chr(225).chr(187).chr(135) => 'e',
  158. chr(225).chr(187).chr(138) => 'I', chr(225).chr(187).chr(139) => 'i',
  159. chr(225).chr(187).chr(140) => 'O', chr(225).chr(187).chr(141) => 'o',
  160. chr(225).chr(187).chr(152) => 'O', chr(225).chr(187).chr(153) => 'o',
  161. chr(225).chr(187).chr(162) => 'O', chr(225).chr(187).chr(163) => 'o',
  162. chr(225).chr(187).chr(164) => 'U', chr(225).chr(187).chr(165) => 'u',
  163. chr(225).chr(187).chr(176) => 'U', chr(225).chr(187).chr(177) => 'u',
  164. chr(225).chr(187).chr(180) => 'Y', chr(225).chr(187).chr(181) => 'y',
  165. // Vowels with diacritic (Chinese, Hanyu Pinyin)
  166. chr(201).chr(145) => 'a',
  167. // macron
  168. chr(199).chr(149) => 'U', chr(199).chr(150) => 'u',
  169. // acute accent
  170. chr(199).chr(151) => 'U', chr(199).chr(152) => 'u',
  171. // caron
  172. chr(199).chr(141) => 'A', chr(199).chr(142) => 'a',
  173. chr(199).chr(143) => 'I', chr(199).chr(144) => 'i',
  174. chr(199).chr(145) => 'O', chr(199).chr(146) => 'o',
  175. chr(199).chr(147) => 'U', chr(199).chr(148) => 'u',
  176. chr(199).chr(153) => 'U', chr(199).chr(154) => 'u',
  177. // grave accent
  178. chr(199).chr(155) => 'U', chr(199).chr(156) => 'u',
  179. );
  180. // Used for locale-specific rules
  181. $locale = get_locale();
  182. if ( 'de_DE' == $locale || 'de_DE_formal' == $locale ) {
  183. $chars[ chr(195).chr(132) ] = 'Ae';
  184. $chars[ chr(195).chr(164) ] = 'ae';
  185. $chars[ chr(195).chr(150) ] = 'Oe';
  186. $chars[ chr(195).chr(182) ] = 'oe';
  187. $chars[ chr(195).chr(156) ] = 'Ue';
  188. $chars[ chr(195).chr(188) ] = 'ue';
  189. $chars[ chr(195).chr(159) ] = 'ss';
  190. } elseif ( 'da_DK' === $locale ) {
  191. $chars[ chr(195).chr(134) ] = 'Ae';
  192. $chars[ chr(195).chr(166) ] = 'ae';
  193. $chars[ chr(195).chr(152) ] = 'Oe';
  194. $chars[ chr(195).chr(184) ] = 'oe';
  195. $chars[ chr(195).chr(133) ] = 'Aa';
  196. $chars[ chr(195).chr(165) ] = 'aa';
  197. }
  198. $string = strtr($string, $chars);
  199. } else {
  200. $chars = array();
  201. // Assume ISO-8859-1 if not UTF-8
  202. $chars['in'] = chr(128).chr(131).chr(138).chr(142).chr(154).chr(158)
  203. .chr(159).chr(162).chr(165).chr(181).chr(192).chr(193).chr(194)
  204. .chr(195).chr(196).chr(197).chr(199).chr(200).chr(201).chr(202)
  205. .chr(203).chr(204).chr(205).chr(206).chr(207).chr(209).chr(210)
  206. .chr(211).chr(212).chr(213).chr(214).chr(216).chr(217).chr(218)
  207. .chr(219).chr(220).chr(221).chr(224).chr(225).chr(226).chr(227)
  208. .chr(228).chr(229).chr(231).chr(232).chr(233).chr(234).chr(235)
  209. .chr(236).chr(237).chr(238).chr(239).chr(241).chr(242).chr(243)
  210. .chr(244).chr(245).chr(246).chr(248).chr(249).chr(250).chr(251)
  211. .chr(252).chr(253).chr(255);
  212. $chars['out'] = "EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy";
  213. $string = strtr($string, $chars['in'], $chars['out']);
  214. $double_chars = array();
  215. $double_chars['in'] = array(chr(140), chr(156), chr(198), chr(208), chr(222), chr(223), chr(230), chr(240), chr(254));
  216. $double_chars['out'] = array('OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th');
  217. $string = str_replace($double_chars['in'], $double_chars['out'], $string);
  218. }
  219. return $string;
  220. }
1182  Programación / Programación C/C++ / Re: Quitar acentos de un string en: 10 Julio 2015, 01:56 am
Si el código está hecho en utf8 o en latín iso y usas otra codificación en la entrada de texto del terminal no realizará las validaciones ya que á en utf8 no es lo mismo que á en latín iso o en otras codificaciones ya que el valor decimal es diferente.

Lo que yo haría es crear la misma lista blanca pero con sus valores respectivos en decimal y detectar la codificación del texto y en base a eso realizar la conversión

Ahora, una pregunta: necesitas reemplazar únicamente acentos? que pasa con las eñes y ¨? y los demás caracteres especiales que se usan en otros lenguajes?

Mira, acá hay un proyecto que ya hace lo que necesitas:
http://stackoverflow.com/questions/2992066/code-to-strip-diacritical-marks-using-icu
http://stackoverflow.com/questions/144761/how-to-remove-accents-and-tilde-in-a-c-stdstring

http://site.icu-project.org/
1183  Programación / Programación General / Re: Eclipse-Android--------- R cannot be resolved to a variable en: 7 Julio 2015, 03:27 am
Por el momento el foro no tiene una sección de programación en android, pero de todas maneras puedes postearlas en la sección de java ya que al final android está basado en java o si no buscar algún otro foro especializado.
1184  Programación / Programación General / Re: Eclipse-Android--------- R cannot be resolved to a variable en: 6 Julio 2015, 01:00 am
Eso sucede porque no has descargado los sdk de desarrollo, si el proyecto no resuelve R es porque no se ha podido resolver la api nativa. Abre el sdk manager y descarga la version de android sobre la que deseas trabajar, despues de finalizar le das en compilar a tu proyecto y listo.

Si eres principiante entonces no te recomiendo usar eclipse, usa android studio:
http://developer.android.com/intl/es/sdk/index.html

saludos.
1185  Programación / Programación General / Re: Hilo oficial: Solicitudes de Expresiones Regulares en: 5 Julio 2015, 19:11 pm
Validación de URL:

Código:
^((mailto\:|(news|(ht|f)tp(s?))\:\/\/){1}\S+)$

Ejemplos:
Código:
http://www.google.cl/
ftp://www.google.cl/
mailto:demo@google.com
1186  Programación / Programación General / Re: Hilo oficial: Solicitudes de Expresiones Regulares en: 5 Julio 2015, 18:50 pm
Está bueno agrupar en 3 el grupo de la red a diferencia de la de owasp que las hace por separado, pero de todas maneras deberías agregarle el comienzo ^ y el final $ o si no cuando uses esa validación en un campo de texto que solo soporte un valor de ip validará texto basura antes y después de la ip como por ejemplo:

Código:
127.0.0.1' union select '1

Dando paso a una inyección SQL :P

Código:
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' A pattern that matches an IPv4 address.
'''
''' For Example:
''' 127.0.0.1
''' </summary>
''' ----------------------------------------------------------------------------------------------------
Public Const Ipv4 As String = "^((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])$"

En ese caso a tu clase deberías agregarle una opción booleana que indique si debe realizar una validación exacta o parcial, o sea con todo el contenido o parte de el en el caso que quieras validar ya que en tu código solo estás buscando una ip y no validando.
1187  Programación / Programación General / Re: Hilo oficial: Solicitudes de Expresiones Regulares en: 5 Julio 2015, 18:32 pm
Obtener el contenido entre etiquetas XHTML:

Código
Código:
<div id="demo">Contenido</div>

Expresión
Código:
/<div\sid="demo">(.+?)<\/div>/si

Resultado:
Código:
Contenido
1188  Programación / Programación General / Re: Hilo oficial: Solicitudes de Expresiones Regulares en: 5 Julio 2015, 18:17 pm
Pues es mas dificil a menos que cambies el orden pero tendras que adivinar o tener un diccionario de nombres y apellidos.

Acá les dejo un repositorio muy bueno sobre expresiones regulares y validaciones:
https://www.owasp.org/index.php/OWASP_Validation_Regex_Repository


Citar
Note
    These Regexs are examples and not built for a particular Regex engine. However, the PCRE syntax is mainly used. In particular, this means that character classes do not contain meta characters which need to be escaped, except the - and ] character, where it is assumed that a - needs not to be escaped only when it is the last character in a character class. The character class supports shortcut notations for other character classes like \s or \w which should not be used as they depend on the LOCALE environment setting in most systems.

Please carefully test the regex in your regex engine.

Código
  1. <?xml version="1.0"?>
  2.  
  3.  <regex>
  4.   <name>url</name>
  5.   <pattern><![CDATA[^((((https?|ftps?|gopher|telnet|nntp)://)|(mailto:|news:))(%[0-9A-Fa-f]{2}|[-()_.!~*';/?:@&=+$,A-Za-z0-9])+)([).!';/?:,][[:blank:]])?$]]></pattern>
  6.   <description>A valid URL per the URL spec.</description>
  7.  </regex>
  8.  
  9.  <regex>
  10.   <name>IP</name>
  11.   <pattern><![CDATA[^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$]]></pattern>
  12.   <description>A valid IP Address</description>
  13.  </regex>
  14.  
  15.  <regex>
  16.   <name>e-mail</name>
  17.   <pattern><![CDATA[^[a-zA-Z0-9+&*-]+(?:\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,7}$]]></pattern>
  18.   <description>A valid e-mail address</description>
  19.  </regex>
  20.  
  21.  <regex>
  22.   <name>safetext</name>
  23.   <pattern><![CDATA[^[a-zA-Z0-9 .-]+$]]></pattern>
  24.   <description>Lower and upper case letters and all digits</description>
  25.  </regex>
  26.  
  27.  <regex>
  28.   <name>date</name>
  29.   <pattern><![CDATA[^(?:(?:(?:0?[13578]|1[02])(\/|-|\.)31)\1|(?:(?:0?[1,3-9]|1[0-2])(\/|-|\.)(?:29|30)\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})$|^(?:0?2(\/|-|\.)29\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:(?:0?[1-9])|(?:1[0-2]))(\/|-|\.)(?:0?[1-9]|1\d|2[0-8])\4(?:(?:1[6-9]|[2-9]\d)?\d{2})$]]></pattern>
  30.   <description>Date in US format with support for leap years</description>
  31.  </regex>
  32.  
  33.  <regex>
  34.   <name>creditcard</name>
  35.   <pattern><![CDATA[^((4\d{3})|(5[1-5]\d{2})|(6011)|(7\d{3}))-?\d{4}-?\d{4}-?\d{4}|3[4,7]\d{13}$]]></pattern>
  36.   <description>A valid credit card number</description>
  37.  </regex>
  38.  
  39.  <regex>
  40.   <name>password</name>
  41.   <pattern><![CDATA[^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{4,8}$]]></pattern>
  42.   <description>4 to 8 character password requiring numbers and both lowercase and uppercase letters</description>
  43.  </regex>
  44.  
  45.  <regex>
  46.   <name>complexpassword</name>
  47.   <pattern><![CDATA[^(?:(?=.*\d)(?=.*[A-Z])(?=.*[a-z])|(?=.*\d)(?=.*[^A-Za-z0-9])(?=.*[a-z])|(?=.*[^A-Za-z0-9])(?=.*[A-Z])(?=.*[a-z])|(?=.*\d)(?=.*[A-Z])(?=.*[^A-Za-z0-9]))(?!.*(.)\1{2,})[A-Za-z0-9!~<>,;:_=?*+#."&§%°()\|\[\]\-\$\^\@\/]{8,32}$]]></pattern>
  48.   <description>4 to 32 character password requiring at least 3 out 4 (uppercase and lowercase letters, numbers and special characters) and no more than 2 equal characters in a row</description>
  49.  </regex>
  50.  
  51.  <regex>
  52.   <name>English_digitwords</name>
  53.   <pattern><![CDATA[^(zero|one|two|three|four|five|six|seven|eight|nine)$]]></pattern>
  54.   <description>The English words representing the digits 0 to 9</description>
  55.  </regex>
  56.  
  57.  <regex>
  58.   <name>English_daywords</name>
  59.   <pattern><![CDATA[^(Mo|Tu|We|Th|Fr|Sa|Su)$]]></pattern>
  60.   <description>English 2 character abbreviations for the days of the week</description>
  61.  </regex>
  62.  
  63.  <regex>
  64.   <name>English_monthwords</name>
  65.   <pattern><![CDATA[^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)$]]></pattern>
  66.   <description>English 3 character abbreviations for the months</description>
  67.  </regex>
  68.  
  69.  <regex>
  70.   <name>French_digitwords</name>
  71.   <pattern><![CDATA[^(z[eé]ro|un|deux|trois|quatre|cinq|six|sept|huit|neuf)$]]></pattern>
  72.   <description>The French words representing the digits 0 to 9</description>
  73.  </regex>
  74.  
  75.  <regex>
  76.   <name>German_digitwords</name>
  77.   <pattern><![CDATA[^(null|eins|zwei|drei|vier|f(ue|ü)nf|sechs|sieben|acht|neun)$]]></pattern>
  78.   <description>The German words representing the digits 0 to 9</description>
  79.  </regex>
  80.  
  81.  <regex>
  82.   <name>Spanish_digitwords</name>
  83.   <pattern><![CDATA[^(cero|uno|dos|tres|cuatro|cinco|seis|siete|ocho|nueve)$]]></pattern>
  84.   <description>The Spanish words representing the digits 0 to 9</description>
  85.  </regex>
  86.  
  87.  <regex>
  88.   <name>US_zip</name>
  89.   <pattern><![CDATA[^\d{5}(-\d{4})?$]]></pattern>
  90.   <description>US zip code with optional dash-four</description>
  91.  </regex>
  92.  
  93.  <regex>
  94.   <name>US_phone</name>
  95.   <pattern><![CDATA[^\D?(\d{3})\D?\D?(\d{3})\D?(\d{4})$]]></pattern>
  96.   <description>US phone number with or without dashes</description>
  97.  </regex>
  98.  
  99.  <regex>
  100.   <name>US_state</name>
  101.   <pattern><![CDATA[^(AE|AL|AK|AP|AS|AZ|AR|CA|CO|CT|DE|DC|FM|FL|GA|GU|HI|ID|IL|IN|IA|KS|KY|LA|ME|MH|MD|MA|MI|MN|MS|MO|MP|MT|NE|NV|NH|NJ|NM|NY|NC|ND|OH|OK|OR|PW|PA|PR|RI|SC|SD|TN|TX|UT|VT|VI|VA|WA|WV|WI|WY)$]]></pattern>
  102.   <description>2 letter U.S. state abbreviations</description>
  103.  </regex>
  104.  
  105.  <regex>
  106.   <name>US_ssn</name>
  107.   <pattern><![CDATA[^\d{3}-\d{2}-\d{4}$]]></pattern>
  108.   <description>9 digit U.S. social security number with dashes</description>
  109.  </regex>
  110.  
  111.  <!-- Some additional examples that have not been vetted
  112.  
  113.       // HTML HEX CODE   ^#?([a-f]|[A-F]|[0-9]){3}(([a-f]|[A-F]|[0-9]){3})?$
  114.       // FLOATING POINT   ^[-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?$
  115.       // PERSON NAME   ^[a-zA-Z]+(([',. -][a-zA-Z ])?[a-zA-Z]*)*$
  116.       // MAC ADDRESS  ^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$
  117.       // GUID    ^[A-Z0-9]{8}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{12}$
  118.       // IP ADDRESS  ^\b((25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)\.){3}(25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)\b$
  119.       // IP ADDRESS (^\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b$
  120.       // REASONABLE DOMAIN NAME   ^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}$
  121.       // RFC 1918 NON ROUTABLE IP   ^(((25[0-5]|2[0-4][0-9]|19[0-1]|19[3-9]|18[0-9]|17[0-1]|17[3-9]|1[0-6][0-9]|1[1-9]|[2-9][0-9]|[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]))|(192\.(25[0-5]|2[0-4][0-9]|16[0-7]|169|1[0-5][0-9]|1[7-9][0-9]|[1-9][0-9]|[0-9]))|(172\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|1[0-5]|3[2-9]|[4-9][0-9]|[0-9])))\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$
  122.       // VALID WINDOWS FILENAME  ^(?!^(PRN|AUX|CLOCK\$|NUL|CON|COM\d|LPT\d|\..*)(\..+)?$)[^\x00-\x1f\\?*:\";|/]+$
  123.       //
  124.       //
  125.       // Warning, per http://en.wikipedia.org/wiki/ReDoS the Java Classname RegEx below is vulnerable to RegExDos
  126.       // Java Classname  ^(([a-z])+.)+[A-Z]([a-z])+$
  127.       //
  128.       //  ANY PLATFORM FILENAME   ^(([a-zA-Z]:|\\)\\)?(((\.)|(\.\.)|([^\\/:*?"|<>. ](([^\\/:*?"|<>. ])|([^\\/:*?"|<>]*[^\\/:*?"|<>. ]))?))\\)*[^\\/:*?"|<>. ](([^\\/:*?"|<>. ])|([^\\/:*?"|<>]*[^\\/:*?"|<>. ]))?$
  129.  -->
  130.  

Yo uso muchos de ellos en mis desarrollos.

Saludos.
1189  Foros Generales / Noticias / Re: La próxima versión de Firefox viene con una sorpresa… algo desagradable en: 5 Julio 2015, 02:27 am
Google Chrome ya lo hace y mientras mozilla sea imparcial no habrá problema, por lo contrario, para mi sería de muy buena ayuda ya que no necesitaría entrar a google para encontrar rápidamente el enlace que necesito. Esto no es nuevo y tampoco lo veo como una "sorpresa desagradable" en ninguna manera, esto aumentará la precisión de lo que estoy buscando. Pero ojo, siempre y cuando estas sugerencias sean imparciales, ya que en caso de que no lo fuera como lo hace ubuntu con el menú de inicio y los resultados de amazon entonces ahi si estaría en total desacuerdo, pero mientras sea utilizado a mi beneficio como lo hace google en el buscador entonces no hay problema.
1190  Foros Generales / Noticias / Re: Nova OS, así es el sistema que utilizan los ordenadores en Cuba en: 1 Julio 2015, 16:57 pm
De esta manera en cierta forma previenen el espionaje por parte de las empresas que maneja el gobierno de los estados unidos a través de la nsa.

Si hubiera una guerra y el gobierno opositor a estados unidos usa windows en sus pc y servidores, crees que no tendrían acceso a sus datos confidenciales?, Apple es una empresa diseñada a la alternativa a windows, el que no le gusta windows usa mac y el control estaría asegurado por igual, salvo con Linux, mas que la guerra por la estabilidad económica es el poder de la información y seguimiento, una forma de asegurarse en el futuro de posibles guerras y conflictos, eso de asegurarse contra el terrorismo es solo una escusa y de esto china, rusia y al parecer ahora cuba entienden muy bien.
Páginas: 1 ... 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 [119] 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 ... 456
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines