/assets/javascripts/miniapplet.js

https://github.com/descala/haltr · JavaScript · 1685 lines · 1031 code · 284 blank · 370 comment · 377 complexity · 705d67f8c50fa1d048c0ae1ac1f90302 MD5 · raw file 

    

  1. if (document.all && !window.setTimeout.isPolyfill) {

    2. 

  2. 	var __nativeST__ = window.setTimeout;

    3. 

  3. 	window.setTimeout = function (vCallback, nDelay /*, argumentToPass1, argumentToPass2, etc. */) {

    4. 

  4. 		var aArgs = Array.prototype.slice.call(arguments, 2);

    5. 

  5. 		return __nativeST__(vCallback instanceof Function ? function () {

    6. 

  6. 			vCallback.apply(null, aArgs);

    7. 

  7. 		} : vCallback, nDelay);

    8. 

  8. 	};

    9. 

  9. 	window.setTimeout.isPolyfill = true;

    10. 

  10. }

    11. 

  11. 

    12. 

  12. var MiniApplet = {

    13. 

  13. 

    14. 

  14. 		VERSION : "1.2",

    15. 

  15. 		

    16. 

  16. 		JAR_NAME : 'miniapplet-full_1_2u1.jar',

    17. 

  17. 

    18. 

  18. 		JAVA_ARGUMENTS : '-Xms512M -Xmx512M',

    19. 

  19. 		

    20. 

  20. 		CUSTOM_JAVA_ARGUMENTS : null,

    21. 

  21. 		

    22. 

  22. 		clienteFirma : null,

    23. 

  23. 

    24. 

  24. 		codeBase : null,

    25. 

  25. 

    26. 

  26. 		storageServletAddress : null,

    27. 

  27. 		

    28. 

  28. 		retrieverServletAddress : null,

    29. 

  29. 		

    30. 

  30. 		clientType : null,

    31. 

  31. 		

    32. 

  32. 		severeTimeDelay : false,

    33. 

  33. 

    34. 

  34. 		selectedLocale : null,

    35. 

  35. 		

    36. 

  36. 		/* Almacenes de certificados */

    37. 

  37. 

    38. 

  38. 		KEYSTORE_WINDOWS : "WINDOWS",

    39. 

  39. 

    40. 

  40. 		KEYSTORE_APPLE : "APPLE",

    41. 

  41. 		

    42. 

  42. 		KEYSTORE_PKCS12 : "PKCS12",

    43. 

  43. 

    44. 

  44. 		KEYSTORE_PKCS11 : "PKCS11",

    45. 

  45. 

    46. 

  46. 		KEYSTORE_FIREFOX : "MOZ_UNI",

    47. 

  47. 

    48. 

  48. 		/* Valores para la configuracion de la comprobacion de tiempo */

    49. 

  49. 

    50. 

  50. 		CHECKTIME_NO : "CT_NO",

    51. 

  51. 

    52. 

  52. 		CHECKTIME_RECOMMENDED : "CT_RECOMMENDED",

    53. 

  53. 		

    54. 

  54. 		CHECKTIME_OBLIGATORY : "CT_OBLIGATORY",

    55. 

  55. 		

    56. 

  56. 		/* ------------------------------------------------ */

    57. 

  57. 		/* Constantes para la operacion interna del Cliente */

    58. 

  58. 		/* ------------------------------------------------ */

    59. 

  59. 		

    60. 

  60. 		/* Longitud maximo de una URL en Android para la invocacion de una aplicacion nativa. */

    61. 

  61. 		MAX_LONG_ANDROID_URL : 2000,

    62. 

  62. 		

    63. 

  63. 		/* Longitud maximo de una URL en iOS para la invocacion de una aplicacion nativa. */

    64. 

  64. 		MAX_LONG_IOS_URL : 80000,

    65. 

  65. 		

    66. 

  66. 		/* Longitud maximo de una URL en Windows 8 para la invocacion de una aplicacion nativa. */

    67. 

  67. 		MAX_LONG_WINDOWS8_URL : 2000,

    68. 

  68. 

    69. 

  69. 		/* Tamano del buffer con el que se pasa informacion al applet */

    70. 

  70. 		BUFFER_SIZE : 1024 * 1024,

    71. 

  71. 		

    72. 

  72. 		/* Cadena que determina el fin de una respuesta */

    73. 

  73. 		EOF : "%%EOF%%",

    74. 

  74. 		

    75. 

  75. 		TYPE_APPLET : "APPLET",

    76. 

  76. 		

    77. 

  77. 		TYPE_JAVASCRIPT : "JAVASCRIPT",

    78. 

  78. 		

    79. 

  79. 		/* ------------------------------------ */

    80. 

  80. 		/* Funciones de comprobacion de entorno */

    81. 

  81. 		/* ------------------------------------ */

    82. 

  82. 

    83. 

  83. 		/**

    84. 

  84. 		 * Determina con un boolean si nuestro cliente es Android

    85. 

  85. 		 */

    86. 

  86. 		isAndroid : function () {

    87. 

  87. 			return navigator.userAgent.toUpperCase().indexOf("ANDROID") != -1 ||

    88. 

  88. 				navigator.appVersion.toUpperCase().indexOf("ANDROID") != -1 ||

    89. 

  89. 				// Para la deteccion de los Kindle Fire

    90. 

  90. 				navigator.userAgent.toUpperCase().indexOf("SILK/") != -1 ||

    91. 

  91. 				navigator.userAgent.toUpperCase().indexOf("KFJWI") != -1 ||

    92. 

  92. 				navigator.userAgent.toUpperCase().indexOf("KFJWA") != -1 ||

    93. 

  93. 				navigator.userAgent.toUpperCase().indexOf("KFTT") != -1 ||

    94. 

  94. 				navigator.userAgent.toUpperCase().indexOf("KFOT") != -1 ||

    95. 

  95. 				navigator.userAgent.toUpperCase().indexOf("KINDLE FIRE") != -1

    96. 

  96. 				;

    97. 

  97. 		},

    98. 

  98. 

    99. 

  99. 		/**

    100. 

  100. 		 * Determina con un boolean si nuestro cliente es iOS.

    101. 

  101. 		 */

    102. 

  102. 		isIOS : function () {

    103. 

  103. 			return (navigator.userAgent.toUpperCase().indexOf("IPAD") != -1) ||

    104. 

  104. 			(navigator.userAgent.toUpperCase().indexOf("IPOD") != -1) ||

    105. 

  105. 			(navigator.userAgent.toUpperCase().indexOf("IPHONE") != -1);

    106. 

  106. 		},

    107. 

  107. 

    108. 

  108. 		/** Comprueba si se permite la ejecucion de ActiveX. */

    109. 

  109. 		isActivexEnabled : function () {

    110. 

  110. 			var supported = null;

    111. 

  111. 			try {

    112. 

  112. 				supported = !!new ActiveXObject("htmlfile");

    113. 

  113. 			} catch (e) {

    114. 

  114. 				supported = false;

    115. 

  115. 			}

    116. 

  116. 

    117. 

  117. 			return supported;

    118. 

  118. 		},

    119. 

  119. 

    120. 

  120. 		/** Determina con un boolean si nos encontramos en Windows 8/8.1 */

    121. 

  121. 		isWindows8 : function () {

    122. 

  122. 			return navigator.userAgent.indexOf("Windows NT 6.2") != -1 ||	/* Windows 8 */

    123. 

  123. 				navigator.userAgent.indexOf("Windows NT 6.3") != -1;		/* Windows 8.1 */

    124. 

  124. 		},

    125. 

  125. 		

    126. 

  126. 		/** Determina con un boolean si nos encontramos en Windows RT */

    127. 

  127. 		isWindowsRT : function () {

    128. 

  128. 			return MiniApplet.isWindows8() && navigator.userAgent.indexOf("ARM;") != -1;

    129. 

  129. 		},

    130. 

  130. 

    131. 

  131. 		/** Determina con un boolean si estamos en Internet Explorer */

    132. 

  132. 		isInternetExplorer : function () {

    133. 

  133. 			return !!(navigator.userAgent.match(/MSIE/))	/* Internet Explorer 10 o inferior */

    134. 

  134. 					|| !!(navigator.userAgent.match(/Trident/) && navigator.userAgent.match(/rv:11/)); /* Internet Explorer 11 o superior */

    135. 

  135. 		},

    136. 

  136. 		

    137. 

  137. 		isFirefoxUAM : function () {

    138. 

  138. 		    return navigator.userAgent.indexOf("UAM") > 0;

    139. 

  139. 		},

    140. 

  140. 		

    141. 

  141. 		/** Determina con un boolean si nos encontramos en un entorno Windows 8 en modo "Modern UI".

    142. 

  142. 		 * Este metodo no es infalible dado que el navegador no ofrece forma de saberlo.

    143. 

  143. 		 * La comprobacion . */

    144. 

  144. 		isWindows8ModernUI : function () {

    145. 

  145. 			return MiniApplet.isWindows8() && !MiniApplet.isActivexEnabled() && MiniApplet.isInternetExplorer();

    146. 

  146. 		},

    147. 

  147. 

    148. 

  148. 		/**

    149. 

  149. 		 * Determina con un boolean si se accede a la web con Chrome

    150. 

  150. 		 */

    151. 

  151. 		isChrome : function () {

    152. 

  152. 			return navigator.userAgent.toUpperCase().indexOf("CHROME") != -1 ||

    153. 

  153. 				navigator.userAgent.toUpperCase().indexOf("CHROMIUM") != -1;

    154. 

  154. 		},

    155. 

  155. 		

    156. 

  156. 		/**

    157. 

  157. 		 * Determina con un boolean si el navegador es Internet Explorer 10

    158. 

  158. 		 */

    159. 

  159. 		isIE10 : function () {

    160. 

  160. 			return navigator.userAgent.toUpperCase().indexOf("MSIE 10.0") != -1;

    161. 

  161. 		},

    162. 

  162. 		

    163. 

  163. 		/**

    164. 

  164. 		 * Determina con un boolean si el navegador es Internet Explorer 11

    165. 

  165. 		 */

    166. 

  166. 		isIE11 : function () {

    167. 

  167. 			return !!navigator.userAgent.match(/Trident.*rv 11\./);

    168. 

  168. 		},

    169. 

  169. 

    170. 

  170. 		isURLTooLong : function (url) {

    171. 

  171. 			if (MiniApplet.isAndroid()) {

    172. 

  172. 				return url.length > MiniApplet.MAX_LONG_ANDROID_URL;

    173. 

  173. 			}

    174. 

  174. 			else if (MiniApplet.isIOS()) {

    175. 

  175. 				return url.length > MiniApplet.MAX_LONG_IOS_URL;

    176. 

  176. 			}

    177. 

  177. 			else if (MiniApplet.isWindows8()) {

    178. 

  178. 				return url.length > MiniApplet.MAX_LONG_WINDOWS8_URL;

    179. 

  179. 			}

    180. 

  180. 			return false;

    181. 

  181. 		},

    182. 

  182. 		

    183. 

  183. 		/** Indica si el navegador detecta Java. Este valor no es completamente fiable, ya que

    184. 

  184. 		 * Internet Explorer siempre indica que si esta activado. */

    185. 

  185. 		isJavaEnabled : function () {

    186. 

  186. 			return navigator.javaEnabled();

    187. 

  187. 		},

    188. 

  188. 

    189. 

  189. 		/** Permite habilitar la comprobacion de la hora local contra la hora del servidor y

    190. 

  190. 		 * establecer un tiempo maximo permitido y el comportamiento si se supera.

    191. 

  191. 		 * Parametros:

    192. 

  192. 		 *  - checkType:	Tipo de comprobacion. Admite los valores CT_NO, CT_RECOMMENDED y CT_OBLIGATORY.

    193. 

  193. 		 *  - maxMillis:	Tiempo maximo de desfase en milisegundos.

    194. 

  194. 		 * Cuando el HTML es local, no se realiza ningun tipo de comprobacion.

    195. 

  195. 		 * */

    196. 

  196. 		checkTime : function (checkType, maxMillis) {

    197. 

  197. 

    198. 

  198. 			if (checkType == undefined || checkType == null || checkType == MiniApplet.CT_NO

    199. 

  199. 					|| maxMillis == undefined || maxMillis == null || maxMillis <= 0) {

    200. 

  200. 				return;

    201. 

  201. 			}

    202. 

  202. 			

    203. 

  203. 			// Hacemos una llamada al servidor para conocer su hora

    204. 

  204. 			var xhr = new XMLHttpRequest(); 

    205. 

  205. 			xhr.open('GET', document.URL + '/' + Math.random(), false); 

    206. 

  206. 			xhr.send(); 

    207. 

  207. 

    208. 

  208. 			// Recogemos la hora local, nada mas obtener la respuesta del servidor

    209. 

  209. 			var clientDate = new Date();

    210. 

  210. 			

    211. 

  211. 			// Tomamos la hora a partir de la respuesta del servidor. Si esta es 0, estamos en local

    212. 

  212. 			var serverDate = new Date(xhr.getResponseHeader("Date"));

    213. 

  213. 			if (serverDate == null || serverDate.getTime() == 0) {

    214. 

  214. 				// No hacemos nada si estamos en local 

    215. 

  215. 				return;

    216. 

  216. 			}

    217. 

  217. 

    218. 

  218. 			var delay =  Math.abs(clientDate.getTime() - serverDate.getTime());

    219. 

  219. 			if (delay > maxMillis) {

    220. 

  220. 				 if (checkType == MiniApplet.CHECKTIME_RECOMMENDED) {

    221. 

  221. 					 alert("Se ha detectado un desfase horario entre su sistema y el servidor. Se recomienda que se corrija antes de pulsar Aceptar para continuar." +

    222. 

  222. 							 "\nHora de su sistema: " + clientDate.toLocaleString() +

    223. 

  223. 							 "\nHora del servidor: " + serverDate.toLocaleString());

    224. 

  224. 				 }

    225. 

  225. 				 else if (checkType == MiniApplet.CHECKTIME_OBLIGATORY) {

    226. 

  226. 					 MiniApplet.severeTimeDelay = true;

    227. 

  227. 					 alert("Se ha detectado un desfase horario entre su sistema y el servidor. Debe corregir la hora de su sistema antes de continuar." +

    228. 

  228. 							 "\nHora de su sistema: " + clientDate.toLocaleString() +

    229. 

  229. 							 "\nHora del servidor: " + serverDate.toLocaleString());

    230. 

  230. 				 }

    231. 

  231. 			}

    232. 

  232. 		},

    233. 

  233. 

    234. 

  234. 		/** Establece los parametros de configuracion para la correcta seleccion del almacen

    235. 

  235. 		 * de claves que se debe cargar. */

    236. 

  236. 		configureKeyStore : function () {

    237. 

  237. 			if (MiniApplet.isFirefoxUAM()) {

    238. 

  238. 				if (MiniApplet.CUSTOM_JAVA_ARGUMENTS == null) {

    239. 

  239. 					MiniApplet.CUSTOM_JAVA_ARGUMENTS = "";

    240. 

  240. 				}

    241. 

  241. 				MiniApplet.CUSTOM_JAVA_ARGUMENTS += " -Des.gob.afirma.keystores.mozilla.UseEnvironmentVariables=true";

    242. 

  242. 			}

    243. 

  243. 		},

    244. 

  244. 		

    245. 

  245. 		/** Carga el MiniApplet. */

    246. 

  246. 		cargarMiniApplet : function (base, keystore) {

    247. 

  247. 

    248. 

  248. 			// Antes que nada, comprobamos que no haya un desfase horario declarado como

    249. 

  249. 			// grave.

    250. 

  250. 			if (MiniApplet.severeTimeDelay) {

    251. 

  251. 				return;

    252. 

  252. 			}

    253. 

  253. 			

    254. 

  254. 			// Si estamos claramente en un sistema movil o que no permite la ejecucion de Java,

    255. 

  255. 			// cargamos directamente el Cliente JavaScript

    256. 

  256. 			if (MiniApplet.isAndroid() || MiniApplet.isIOS() || MiniApplet.isWindowsRT()) {

    257. 

  257. 				MiniApplet.cargarAppAfirma(base);

    258. 

  258. 				return;

    259. 

  259. 			}

    260. 

  260. 

    261. 

  261. 			// Si estamos en un entorno que permite Java, comprobamos si esta disponible

    262. 

  262. 			// y en caso de no estarlo, tambien cargamos el Cliente JavaScript.

    263. 

  263. 			if (!MiniApplet.isJavaEnabled()) {

    264. 

  264. 				MiniApplet.cargarAppAfirma(base);

    265. 

  265. 				return;

    266. 

  266. 			}

    267. 

  267. 

    268. 

  268. 			// Configuramos los argumentos para la seleccion de almacen

    269. 

  269. 			MiniApplet.configureKeyStore();

    270. 

  270. 			

    271. 

  271. 			// Incluso si el navegador informa que hay Java, puede no haberlo (Internet Explorer

    272. 

  272. 			// siempre dice que hay), asi que cargamos el applet, pero tenemos en cuenta que en

    273. 

  273. 			// caso de error debemos cargar el cliente JavaScript

    274. 

  274. 			MiniApplet.codeBase = (base != undefined && base != null) ? base : './';

    275. 

  275. 			

    276. 

  276. 			var keystoreConfig = keystore;

    277. 

  277. 			if (keystoreConfig == undefined) {

    278. 

  278. 				keystoreConfig = null;

    279. 

  279. 			}

    280. 

  280. 			

    281. 

  281. 			var attributes = {

    282. 

  282. 					'id': 'miniApplet',

    283. 

  283. 					'name': 'MiniApplet @firma (Gobierno de Espa\u00F1a)',

    284. 

  284. 					'type': 'application/x-java-applet',

    285. 

  285. 					'width': 1,

    286. 

  286. 					'height': 1

    287. 

  287. 			};

    288. 

  288. 			

    289. 

  289. 			// Los argumentos de java no llegan al propio applet en las pruebas con Java 6 y 7,

    290. 

  290. 			// asi que (salvo los argumentos de carga) vamos a pasarlos como un parametro mas al

    291. 

  291. 			// applet para luego establecerlos internamente.

    292. 

  292. 			var parameters = {

    293. 

  293. 					'keystore': keystoreConfig,

    294. 

  294. 					'userAgent': window.navigator.userAgent,

    295. 

  295. 					'archive': MiniApplet.codeBase + '/' + MiniApplet.JAR_NAME,

    296. 

  296. 					'code': 'es.gob.afirma.miniapplet.MiniAfirmaApplet',

    297. 

  297. 					'java-vm-args': MiniApplet.JAVA_ARGUMENTS,

    298. 

  298. 					'java_arguments': MiniApplet.JAVA_ARGUMENTS,

    299. 

  299. 					'custom_java_arguments': MiniApplet.CUSTOM_JAVA_ARGUMENTS,

    300. 

  300. 					'codebase_lookup': false,

    301. 

  301. 					'separate_jvm': true,

    302. 

  302. 					'locale': MiniApplet.selectedLocale

    303. 

  303. 			};

    304. 

  304. 

    305. 

  305. 			MiniApplet.loadMiniApplet(attributes, parameters);

    306. 

  306. 			

    307. 

  307. 			MiniApplet.clienteFirma = document.getElementById("miniApplet");

    308. 

  308. 			

    309. 

  309. 			// Si no esta definido el cliente es porque se ha intentado cargar el applet

    310. 

  310. 			// y no se ha podido, asi que se usara la aplicacion nativa

    311. 

  311. 			if (MiniApplet.clienteFirma == null) {

    312. 

  312. 				MiniApplet.cargarAppAfirma(MiniApplet.codeBase);

    313. 

  313. 			}

    314. 

  314. 		},

    315. 

  315. 				

    316. 

  316. 		sign : function (dataB64, algorithm, format, params, successCallback, errorCallback) {

    317. 

  317. 			

    318. 

  318. 			this.forceLoad();

    319. 

  319. 			if (MiniApplet.clientType == MiniApplet.TYPE_APPLET) {

    320. 

  320. 				try {

    321. 

  321. 					this.setData(dataB64);

    322. 

  322. 					if (successCallback == undefined || successCallback == null) {

    323. 

  323. 						return this.buildData(MiniApplet.clienteFirma.sign(algorithm, format, params));

    324. 

  324. 					}

    325. 

  325. 					successCallback(this.buildData(MiniApplet.clienteFirma.sign(algorithm, format, params)));

    326. 

  326. 				} catch(e) {

    327. 

  327. 					if (errorCallback == undefined || errorCallback == null) {

    328. 

  328. 						throw e;

    329. 

  329. 					}

    330. 

  330. 					errorCallback(MiniApplet.clienteFirma.getErrorType(), MiniApplet.clienteFirma.getErrorMessage());

    331. 

  331. 				}

    332. 

  332. 			}

    333. 

  333.             else if (MiniApplet.clientType == MiniApplet.TYPE_JAVASCRIPT) {

    334. 

  334.               errorCallback('Haltr','Please enable Java')

    335. 

  335. //				MiniApplet.clienteFirma.sign(dataB64, algorithm, format, params, successCallback, errorCallback);

    336. 

  336. 			}

    337. 

  337. 		},

    338. 

  338. 

    339. 

  339. 		coSign : function (signB64, dataB64, algorithm, format, params, successCallback, errorCallback) {

    340. 

  340. 			

    341. 

  341. 			this.forceLoad();

    342. 

  342. 			if (MiniApplet.clientType == MiniApplet.TYPE_APPLET) {

    343. 

  343. 				try {

    344. 

  344. 					this.setData(signB64);

    345. 

  345. 					if (successCallback == undefined || successCallback == null) {

    346. 

  346. 						return this.buildData(MiniApplet.clienteFirma.coSign(dataB64, algorithm, format, params));

    347. 

  347. 					}

    348. 

  348. 					successCallback(this.buildData(MiniApplet.clienteFirma.coSign(dataB64, algorithm, format, params)));

    349. 

  349. 				} catch(e) {

    350. 

  350. 					if (errorCallback == undefined || errorCallback == null) {

    351. 

  351. 						throw e;

    352. 

  352. 					}

    353. 

  353. 					errorCallback(MiniApplet.clienteFirma.getErrorType(), MiniApplet.clienteFirma.getErrorMessage());

    354. 

  354. 				}

    355. 

  355. 			}

    356. 

  356. 			else if (MiniApplet.clientType == MiniApplet.TYPE_JAVASCRIPT) {

    357. 

  357. 				MiniApplet.clienteFirma.coSign(signB64, dataB64, algorithm, format, params, successCallback, errorCallback);

    358. 

  358. 			}

    359. 

  359. 		},

    360. 

  360. 

    361. 

  361. 		counterSign : function (signB64, algorithm, format, params, successCallback, errorCallback) {

    362. 

  362. 			

    363. 

  363. 			this.forceLoad();

    364. 

  364. 			if (MiniApplet.clientType == MiniApplet.TYPE_APPLET) {

    365. 

  365. 				try {

    366. 

  366. 					this.setData(signB64);

    367. 

  367. 					if (successCallback == undefined || successCallback == null) {

    368. 

  368. 						return this.buildData(MiniApplet.clienteFirma.counterSign(algorithm, format, params));

    369. 

  369. 					}

    370. 

  370. 					successCallback(this.buildData(MiniApplet.clienteFirma.counterSign(algorithm, format, params)));

    371. 

  371. 				} catch(e) {

    372. 

  372. 					if (errorCallback == undefined || errorCallback == null) {

    373. 

  373. 						throw e;

    374. 

  374. 					}

    375. 

  375. 					errorCallback(MiniApplet.clienteFirma.getErrorType(), MiniApplet.clienteFirma.getErrorMessage());

    376. 

  376. 				}

    377. 

  377. 			}

    378. 

  378. 			else if (MiniApplet.clientType == MiniApplet.TYPE_JAVASCRIPT) {

    379. 

  379. 				MiniApplet.clienteFirma.counterSign(signB64, algorithm, format, params, successCallback, errorCallback);

    380. 

  380. 			}

    381. 

  381. 		},

    382. 

  382. 

    383. 

  383. 		getBase64FromText : function (plainText, charset) {

    384. 

  384. 			this.forceLoad();

    385. 

  385. 			return MiniApplet.clienteFirma.getBase64FromText(plainText, charset);

    386. 

  386. 		},

    387. 

  387. 

    388. 

  388. 		getTextFromBase64 : function (dataB64, charset) {

    389. 

  389. 			this.forceLoad();

    390. 

  390. 			return MiniApplet.clienteFirma.getTextFromBase64(dataB64, charset);

    391. 

  391. 		},

    392. 

  392. 

    393. 

  393. 		saveDataToFile : function (dataB64, title, fileName, extension, description) {

    394. 

  394. 			this.forceLoad();

    395. 

  395. 			if (MiniApplet.clientType == MiniApplet.TYPE_APPLET) {

    396. 

  396. 				this.setData(dataB64);

    397. 

  397. 				return MiniApplet.clienteFirma.saveDataToFile(title, fileName, extension, description);

    398. 

  398. 			}

    399. 

  399. 			else if (MiniApplet.clientType == MiniApplet.TYPE_JAVASCRIPT) {

    400. 

  400. 				return MiniApplet.clienteFirma.saveDataToFile(dataB64, title, fileName, extension, description);

    401. 

  401. 			}

    402. 

  402. 			return null;

    403. 

  403. 		},

    404. 

  404. 

    405. 

  405. 		getFileNameContentBase64 : function (title, extensions, description, filePath) {

    406. 

  406. 			this.forceLoad();

    407. 

  407. 			return this.buildData(MiniApplet.clienteFirma.getFileNameContentBase64(title, extensions, description, filePath));

    408. 

  408. 		},

    409. 

  409. 

    410. 

  410. 		getMultiFileNameContentBase64 : function (title, extensions, description, filePath) {

    411. 

  411. 			this.forceLoad();

    412. 

  412. 			return this.buildData(MiniApplet.clienteFirma.getMultiFileNameContentBase64(title, extensions, description, filePath));

    413. 

  413. 		},

    414. 

  414. 

    415. 

  415. 		echo : function () {

    416. 

  416. 			this.forceLoad();

    417. 

  417. 			return MiniApplet.clienteFirma.echo();

    418. 

  418. 		},

    419. 

  419. 

    420. 

  420. 		setStickySignatory : function (sticky) {

    421. 

  421. 			this.forceLoad();

    422. 

  422. 			return MiniApplet.clienteFirma.setStickySignatory(sticky);

    423. 

  423. 		},

    424. 

  424. 

    425. 

  425. 		setLocale : function (locale) {

    426. 

  426. 			MiniApplet.selectedLocale = locale;

    427. 

  427. 		},

    428. 

  428. 		

    429. 

  429. 		getErrorMessage : function () {

    430. 

  430. 			this.forceLoad();

    431. 

  431. 			return MiniApplet.clienteFirma.getErrorMessage();

    432. 

  432. 		},

    433. 

  433. 

    434. 

  434. 		getErrorType : function () {

    435. 

  435. 			this.forceLoad();

    436. 

  436. 			return MiniApplet.clienteFirma.getErrorType();

    437. 

  437. 		},

    438. 

  438. 

    439. 

  439. 		getCurrentLog : function () {

    440. 

  440. 			this.forceLoad();

    441. 

  441. 			return	" === JAVASCRIPT INFORMATION === " +

    442. 

  442. 					"\nnavigator.appCodeName: " + navigator.appCodeName +

    443. 

  443. 					"\nnavigator.appName: " +  navigator.appName +

    444. 

  444. 					"\nnavigator.appVersion: " + navigator.appVersion +

    445. 

  445. 					"\nnavigator.platform: " + navigator.platform +

    446. 

  446. 					"\nnavigator.userAgent: " + navigator.userAgent+

    447. 

  447. 					"\nnavigator.javaEnabled(): " + navigator.javaEnabled() +

    448. 

  448. 					"\nscreen.width: " + (window.screen ? screen.width : 0) +

    449. 

  449. 					"\nscreen.height: " + (window.screen ? screen.height : 0) +

    450. 

  450. 					"\n\n   === CLIENTE LOG === \n" + 

    451. 

  451. 					MiniApplet.clienteFirma.getCurrentLog();

    452. 

  452. 		},

    453. 

  453. 		

    454. 

  454. 		setServlets : function (storageServlet,  retrieverServlet) {

    455. 

  455. 			

    456. 

  456. 			MiniApplet.storageServletAddress = storageServlet;

    457. 

  457. 			MiniApplet.retrieverServletAddress = retrieverServlet;

    458. 

  458. 			

    459. 

  459. 			if (MiniApplet.clienteFirma && MiniApplet.clienteFirma.setServlets) {

    460. 

  460. 				MiniApplet.clienteFirma.setServlets(storageServlet,  retrieverServlet);

    461. 

  461. 			}

    462. 

  462. 		},

    463. 

  463. 

    464. 

  464. 		/*************************************************************

    465. 

  465. 		 *  FUNCIONES PARA EL DESPLIEGUE DEL APPLET					 *

    466. 

  466. 		 **************************************************************/

    467. 

  467. 		

    468. 

  468. 		loadMiniApplet : function (attributes, parameters) {

    469. 

  469. 			// Internet Explorer (a excepcion de la version 10) se carga mediante un

    470. 

  470. 			// elemento <object>. El resto con un <embed>.

    471. 

  471. 			if (MiniApplet.isInternetExplorer()) { // && !MiniApplet.isIE10()) {

    472. 

  472. 				

    473. 

  473. 				var appletTag = "<object classid='clsid:8AD9C840-044E-11D1-B3E9-00805F499D93' width='" + attributes["width"] + "' height='" + attributes["height"] + "' id='" + attributes["id"] + "'>";

    474. 

  474. 

    475. 

  475. 				if (attributes != undefined && attributes != null) {

    476. 

  476. 					for (var attribute in attributes) {

    477. 

  477. 						appletTag += "<param name='" + attribute + "' value='" + attributes[attribute] + "' />";

    478. 

  478. 					}

    479. 

  479. 				}

    480. 

  480. 

    481. 

  481. 				if (parameters != undefined && parameters != null) {

    482. 

  482. 					for (var parameter in parameters) {

    483. 

  483. 						appletTag += "<param name='" + parameter + "' value='" + parameters[parameter] + "' />";

    484. 

  484. 					}

    485. 

  485. 				}

    486. 

  486. 

    487. 

  487. 				appletTag += "</object>";

    488. 

  488. 

    489. 

  489. 				// Al agregar con append() estos nodos no se carga automaticamente el applet en IE10 e inferiores, así que

    490. 

  490. 				// hay que usar document.write() o innerHTML. Para asegurarnos de no pisar HTML previo, crearemos un <div>

    491. 

  491. 				// en la pagina, lo recogeremos e insertaremos dentro suyo el codigo del applet.

    492. 

  492. 				var divElem = document.createElement("div");

    493. 

  493. 				var idAtt = document.createAttribute("id");

    494. 

  494. 				idAtt.value = 'divAfirmaApplet';

    495. 

  495. 				divElem.setAttributeNode(idAtt);

    496. 

  496. 

    497. 

  497. 				document.body.appendChild(divElem);

    498. 

  498. 				

    499. 

  499. 				document.getElementById("divAfirmaApplet").innerHTML = appletTag;

    500. 

  500. 			}

    501. 

  501. 			else {

    502. 

  502. 				var embed = document.createElement("embed");

    503. 

  503. 

    504. 

  504. 				if (attributes != undefined && attributes != null) {

    505. 

  505. 					for (var attribute in attributes) {

    506. 

  506. 						var att = document.createAttribute(attribute);

    507. 

  507. 						att.value = attributes[attribute];

    508. 

  508. 						try {

    509. 

  509. 							embed.setAttributeNode(att);

    510. 

  510. 						}

    511. 

  511. 						catch (e) {

    512. 

  512. 							// Probamos este como alternativa en caso de error. Caso detectado en:

    513. 

  513. 							// - IE10 sin modo de compabilidad con el Document Mode de IE7.

    514. 

  514. 							// - Firefox en Mac OS X

    515. 

  515. 							// Este intento no soluciona el error, pero evita que se propague 

    516. 

  516. 							embed.setAttribute(attribute, attributes[attribute]);

    517. 

  517. 						}

    518. 

  518. 					}

    519. 

  519. 				}

    520. 

  520. 

    521. 

  521. 				if (parameters != undefined && parameters != null) {

    522. 

  522. 					for (var parameter in parameters) {

    523. 

  523. 						var att = document.createAttribute(parameter);

    524. 

  524. 						att.value = parameters[parameter];

    525. 

  525. 						embed.setAttributeNode(att);

    526. 

  526. 					}

    527. 

  527. 				}

    528. 

  528. 

    529. 

  529. 				document.body.appendChild(embed);

    530. 

  530. 			}

    531. 

  531. 		},

    532. 

  532. 		

    533. 

  533. 		/**

    534. 

  534. 		 * Establece los datos que debera procesar el applet MiniApplet. 

    535. 

  535. 		 */

    536. 

  536. 		forceLoad : function () {

    537. 

  537. 

    538. 

  538. 			// Antes que nada, comprobamos que no haya un desfase horario declarado como

    539. 

  539. 			// grave.

    540. 

  540. 			if (MiniApplet.severeTimeDelay) {

    541. 

  541. 				return;

    542. 

  542. 			}

    543. 

  543. 			if (MiniApplet.clientType == null) {

    544. 

  544. 				MiniApplet.clienteFirma = document.getElementById("miniApplet");

    545. 

  545. 				try {

    546. 

  546. 					MiniApplet.clienteFirma.echo();

    547. 

  547. 					MiniApplet.clientType = MiniApplet.TYPE_APPLET;

    548. 

  548. 				} catch (e) {

    549. 

  549. 					MiniApplet.cargarAppAfirma(MiniApplet.codeBase);

    550. 

  550. 				}

    551. 

  551. 				MiniApplet.setServlets(MiniApplet.storageServletAddress, MiniApplet.retrieverServletAddress);

    552. 

  552. 			}

    553. 

  553. 		},

    554. 

  554. 		

    555. 

  555. 		/**

    556. 

  556. 		 * Establece los datos que debera procesar el applet MiniApplet. 

    557. 

  557. 		 */

    558. 

  558. 		setData : function (dataB64) {

    559. 

  559. 

    560. 

  560. 			if (dataB64 == null) {

    561. 

  561. 				return;

    562. 

  562. 			}

    563. 

  563. 			else if (dataB64.length <= MiniApplet.BUFFER_SIZE) {

    564. 

  564. 				MiniApplet.clienteFirma.addData(dataB64);	

    565. 

  565. 			}

    566. 

  566. 			else {

    567. 

  567. 				MiniApplet.clienteFirma.addData(dataB64.substring(0, MiniApplet.BUFFER_SIZE));

    568. 

  568. 				this.setData(dataB64.substring(MiniApplet.BUFFER_SIZE));

    569. 

  569. 			}

    570. 

  570. 		},

    571. 

  571. 		

    572. 

  572. 		/**

    573. 

  573. 		 * Construye el resultado de una funcion a partir de los trozos en la que esta los divide. 

    574. 

  574. 		 */

    575. 

  575. 		buildData : function (dataB64) {

    576. 

  576. 			var buffer = dataB64;

    577. 

  577. 			var chunk = MiniApplet.clienteFirma.getRemainingData();

    578. 

  578. 			while(chunk != MiniApplet.EOF) {

    579. 

  579. 				buffer += chunk;

    580. 

  580. 				chunk = MiniApplet.clienteFirma.getRemainingData();

    581. 

  581. 			}

    582. 

  582. 			return buffer;

    583. 

  583. 		},

    584. 

  584. 

    585. 

  585. 		/**************************************************************

    586. 

  586. 		 **************************************************************

    587. 

  587. 		 **************************************************************

    588. 

  588. 		 **************************************************************

    589. 

  589. 		 *  FUNCIONES DEL CLIENTE JAVASCRIPT						  *

    590. 

  590. 		 **************************************************************

    591. 

  591. 		 **************************************************************

    592. 

  592. 		 **************************************************************

    593. 

  593. 		 **************************************************************/

    594. 

  594. 

    595. 

  595. 		/**

    596. 

  596. 		 * Establece el objeto que simula ser el Applet de firma en sistemas en los que no se

    597. 

  597. 		 * soportan los applets.

    598. 

  598. 		 */

    599. 

  599. 		cargarAppAfirma : function (clientAddress) {

    600. 

  600. 			document.miniapplet = new MiniApplet.AppAfirmaJS(clientAddress);

    601. 

  601. 			MiniApplet.clienteFirma = document.miniapplet;

    602. 

  602. 			

    603. 

  603. 			MiniApplet.clientType = MiniApplet.TYPE_JAVASCRIPT;

    604. 

  604. 		},

    605. 

  605. 

    606. 

  606. 

    607. 

  607. 		/**

    608. 

  608. 		 * Objeto JavaScript que va a reemplazar al cliente de firma en los entornos en los que

    609. 

  609. 		 * no pueden ejecutarse applets.

    610. 

  610. 		 */

    611. 

  611. 		AppAfirmaJS : function (clientAddress) {

    612. 

  612. 

    613. 

  613. 			var UnsupportedOperationException = "java.lang.UnsupportedOperationException";

    614. 

  614. 

    615. 

  615. 			/**

    616. 

  616. 			 *  Atributos para la configuracion del objeto sustituto del applet Java de firma

    617. 

  617. 			 */

    618. 

  618. 			this.errorMessage = '';

    619. 

  619. 			this.errorType = '';

    620. 

  620. 

    621. 

  621. 			if (clientAddress.indexOf("://") != -1 && clientAddress.indexOf("/", clientAddress.indexOf("://") + 3) != -1) {

    622. 

  622. 				var servletsBase = clientAddress.substring(0, clientAddress.indexOf("/", clientAddress.indexOf("://") + 3));

    623. 

  623. 				this.retrieverServletAddress = servletsBase + "/SignatureRetrieverServer/RetrieveService";

    624. 

  624. 				this.storageServletAddress = servletsBase + "/SignatureStorageServer/StorageService";

    625. 

  625. 			} else {

    626. 

  626. 				this.retrieverServletAddress = clientAddress + "/SignatureRetrieverServer/RetrieveService";

    627. 

  627. 				this.storageServletAddress = clientAddress + "/SignatureStorageServer/StorageService";

    628. 

  628. 			}

    629. 

  629. 

    630. 

  630. 			/**

    631. 

  631. 			 * Inicia el proceso de firma electronica.

    632. 

  632. 			 * Implementada en el applet Java de firma

    633. 

  633. 			 */

    634. 

  634. 			this.sign = function(dataB64, algorithm, format, extraParams, successCallback, errorCallback) {

    635. 

  635. 				this.signOperation("sign", dataB64, algorithm, format, extraParams, successCallback, errorCallback);

    636. 

  636. 			};

    637. 

  637. 

    638. 

  638. 			/**

    639. 

  639. 			 * Inicia el proceso de cofirma de una firma electr&oacute;nica. 

    640. 

  640. 			 * Implementada en el applet Java de firma.

    641. 

  641. 			 */

    642. 

  642. 			this.coSign = function(signB64, dataB64, algorithm, format, extraParams, successCallback, errorCallback) {

    643. 

  643. 				this.signOperation("cosign", signB64, algorithm, format, extraParams, successCallback, errorCallback);

    644. 

  644. 			};

    645. 

  645. 

    646. 

  646. 			/**

    647. 

  647. 			 * Inicia el proceso de contrafirma de una firma electr&oacute;nica.

    648. 

  648. 			 * Implementada en el applet Java de firma. 

    649. 

  649. 			 */

    650. 

  650. 			this.counterSign = function(signB64, algorithm, format, extraParams, successCallback, errorCallback) {

    651. 

  651. 				this.signOperation("countersign", signB64, algorithm, format, extraParams, successCallback, errorCallback);

    652. 

  652. 			};

    653. 

  653. 

    654. 

  654. 			/**

    655. 

  655. 			 * Realiza una operacion de firma/multifirma.

    656. 

  656. 			 * @param signId Identificador de la operacion a realizar (sign, cosign y countersign).

    657. 

  657. 			 * @param dataB64 Datos o firma en base 64.

    658. 

  658. 			 * @param algorithm Algoritmo de firma.

    659. 

  659. 			 * @param format Formato de firma.

    660. 

  660. 			 * @param extraParams Par&aacute;metros para la configuraci&oacute;n de la operaci&oacute;n.

    661. 

  661. 			 * @param successCallback M&eacute;todo a ejecutar en caso de &eacute;xito.

    662. 

  662. 			 * @param errorCallback M&eacute;todo a ejecutar en caso de error.

    663. 

  663. 			 */

    664. 

  664. 			this.signOperation = function(signId, dataB64, algorithm, format, extraParams, successCallback, errorCallback) {

    665. 

  665. 

    666. 

  666. 				if (dataB64 == undefined || dataB64 == "") {

    667. 

  667. 					dataB64 = null;

    668. 

  668. 				}

    669. 

  669. 				

    670. 

  670. 				if (dataB64 != null) {

    671. 

  671. 					dataB64 = dataB64.replace(/\+/g, "-").replace(/\//g, "_");

    672. 

  672. 				}

    673. 

  673. 

    674. 

  674. 				if (isPolicyConfigurated(extraParams)) {

    675. 

  675. 					extraParams = expandPolicy(format, extraParams);

    676. 

  676. 				}

    677. 

  677. 				

    678. 

  678. 				var idSession = generateNewIdSession();

    679. 

  679. 				var cipherKey = generateCipherKey();

    680. 

  680. 				

    681. 

  681. 				var i = 0;

    682. 

  682. 				var params = new Array();

    683. 

  683. 				if (signId != null && signId != undefined) {			params[i++] = {key:"op", value:encodeURIComponent(signId)}; }

    684. 

  684. 				if (idSession != null && idSession != undefined) {		params[i++] = {key:"id", value:encodeURIComponent(idSession)}; }

    685. 

  685. 				if (cipherKey != null && cipherKey != undefined) {		params[i++] = {key:"key", value:encodeURIComponent(cipherKey)}; }

    686. 

  686. 				if (this.storageServletAddress != null && this.storageServletAddress != undefined) {	params[i++] = {key:"stservlet", value:this.storageServletAddress}; }

    687. 

  687. 				if (format != null && format != undefined) {			params[i++] = {key:"format", value:encodeURIComponent(format)}; }

    688. 

  688. 				if (algorithm != null && algorithm != undefined) {		params[i++] = {key:"algorithm", value:encodeURIComponent(algorithm)}; }

    689. 

  689. 				if (extraParams != null && extraParams != undefined) { 	params[i++] = {key:"properties", value:encodeURIComponent(Base64.encode(extraParams))}; }

    690. 

  690. 				if (MiniApplet.isWindows8()) {							params[i++] = {key:"metro", value:MiniApplet.isWindows8ModernUI() ? "true" : "false"}; }

    691. 

  691. 				if (dataB64 != null) {									params[i++] = {key:"dat", value:encodeURIComponent(dataB64)}; }

    692. 

  692. 

    693. 

  693. 				var url = this.buildUrl(signId, params);

    694. 

  694. 

    695. 

  695. 				// Si la URL es muy larga, realizamos un preproceso para que los datos se suban al

    696. 

  696. 				// servidor y la aplicacion nativa los descargue, en lugar de pasarlos directamente 

    697. 

  697. 				if (MiniApplet.isURLTooLong(url)) {

    698. 

  698. 					if (this.storageServletAddress == null || this.storageServletAddress == undefined) {

    699. 

  699. 						throwException("java.lang.IllegalArgumentException", "No se ha indicado la direccion del servlet para el guardado de datos");

    700. 

  700. 						return;

    701. 

  701. 					}

    702. 

  702. 

    703. 

  703. 					var fileId = this.preProccessData(cipherKey, this.storageServletAddress, signId, params);

    704. 

  704. 					if (!fileId) {

    705. 

  705. 						throwException("java.net.UnknownHostException", "No se han podido enviar los datos a la aplicacion de firma");

    706. 

  706. 						return;

    707. 

  707. 					}

    708. 

  708. 					

    709. 

  709. 					url = this.buildUrlWithoutData(signId, fileId, this.retrieverServletAddress, cipherKey);

    710. 

  710. 					if (MiniApplet.isURLTooLong(url)) {

    711. 

  711. 						throwException("java.lang.IllegalArgumentException", "La URL de invocacion al servicio de firma es demasiado larga.");

    712. 

  712. 						return;

    713. 

  713. 					}

    714. 

  714. 				}

    715. 

  715. 

    716. 

  716. 				this.execAppIntent(url, idSession, cipherKey, successCallback, errorCallback);

    717. 

  717. 			};

    718. 

  718. 

    719. 

  719. 			/**

    720. 

  720. 			 * Convierte texto plano en texto base 64.

    721. 

  721. 			 * Implementada en el applet Java de firma.

    722. 

  722. 			 */

    723. 

  723. 			this.getBase64FromText = function(plainText, charset) {

    724. 

  724. 				return Base64.encode(plainText);

    725. 

  725. 			};

    726. 

  726. 

    727. 

  727. 			/**

    728. 

  728. 			 * Convierte texto base 64 en texto plano.

    729. 

  729. 			 * Implementada en el applet Java de firma.

    730. 

  730. 			 */

    731. 

  731. 			this.getTextFromBase64 = function(base64Text, charset) {

    732. 

  732. 				return Base64.decode(base64Text);

    733. 

  733. 			};

    734. 

  734. 

    735. 

  735. 			/**

    736. 

  736. 			 * Guardado de datos en disco. Se realiza mediante la invocacion de una app nativa. 

    737. 

  737. 			 */

    738. 

  738. 			this.saveDataToFile = function(dataB64, title, filename, extension, description) {

    739. 

  739. 

    740. 

  740. 				if (dataB64 != undefined && dataB64 != null && dataB64 != "") {

    741. 

  741. 					dataB64 = dataB64.replace(/\+/g, "-").replace(/\//g, "_");

    742. 

  742. 				}

    743. 

  743. 				

    744. 

  744. 				var idSession = generateNewIdSession();

    745. 

  745. 				var cipherKey = generateCipherKey();

    746. 

  746. 				

    747. 

  747. 				var i = 0;

    748. 

  748. 				var params = new Array();

    749. 

  749. 				params[i++] = {key:"op", value:"save"};

    750. 

  750. 				if (idSession != null && idSession != undefined) {		params[i++] = {key:"id", value:encodeURIComponent(idSession)}; }

    751. 

  751. 				if (cipherKey != null && cipherKey != undefined) {		params[i++] = {key:"key", value:encodeURIComponent(cipherKey)}; }

    752. 

  752. 				if (this.storageServletAddress != null && this.storageServletAddress != undefined) {	params[i++] = {key:"stservlet", value:this.storageServletAddress}; }

    753. 

  753. 				if (title != null && title != undefined) {				params[i++] = {key:"title", value:encodeURIComponent(title)}; }

    754. 

  754. 				if (filename != null && filename != undefined) {		params[i++] = {key:"filename", value:encodeURIComponent(filename)}; }

    755. 

  755. 				if (extension != null && extension != undefined) {		params[i++] = {key:"extension", value:encodeURIComponent(extension)}; }

    756. 

  756. 				if (description != null && description != undefined) {	params[i++] = {key:"description", value:encodeURIComponent(description)}; }

    757. 

  757. 				if (MiniApplet.isWindows8()) {							params[i++] = {key:"metro", value:MiniApplet.isWindows8ModernUI() ? "true" : "false"}; }

    758. 

  758. 				if (dataB64 != null && dataB64 != undefined && dataB64 != "") {			params[i++] = {key:"dat", value:encodeURIComponent(dataB64)}; }

    759. 

  759. 

    760. 

  760. 				var url = this.buildUrl("save", params);

    761. 

  761. 				

    762. 

  762. 				// Si la URL es muy larga, realizamos un preproceso para que los datos se suban al

    763. 

  763. 				// servidor y la aplicacion nativa los descargue, en lugar de pasarlos directamente 

    764. 

  764. 				if (MiniApplet.isURLTooLong(url)) {

    765. 

  765. 					if (this.storageServletAddress == null || this.storageServletAddress == undefined) {

    766. 

  766. 						throwException("java.lang.IllegalArgumentException", "No se ha indicado la direccion del servlet para el guardado de datos");

    767. 

  767. 						return;

    768. 

  768. 					}

    769. 

  769. 

    770. 

  770. 					var fileId = this.preProccessData(cipherKey, this.storageServletAddress, "save", params);

    771. 

  771. 					if (!fileId) {

    772. 

  772. 						throwException("java.net.UnknownHostException", "No se han podido enviar los datos a la aplicacion de firma");

    773. 

  773. 						return;

    774. 

  774. 					}

    775. 

  775. 					

    776. 

  776. 					url = this.buildUrlWithoutData("save", fileId, this.retrieverServletAddress, cipherKey);

    777. 

  777. 					if (MiniApplet.isURLTooLong(url)) {

    778. 

  778. 						throwException("java.lang.IllegalArgumentException", "La URL de invocacion al servicio de firma es demasiado larga. No se soportan tantas propiedades de configuracion.");

    779. 

  779. 						return;

    780. 

  780. 					}

    781. 

  781. 				}

    782. 

  782. 

    783. 

  783. 				this.execAppIntent(url, idSession, cipherKey);

    784. 

  784. 			};

    785. 

  785. 

    786. 

  786. 			/**

    787. 

  787. 			 * Carga de un fichero. Operacion no soportada. 

    788. 

  788. 			 * Implementada en el applet Java de firma.

    789. 

  789. 			 */

    790. 

  790. 			this.getFileNameContentBase64 = function(title, extensions, description) {

    791. 

  791. 				this.throwException(UnsupportedOperationException, "La operacion de carga de ficheros no esta soportada");

    792. 

  792. 			};

    793. 

  793. 

    794. 

  794. 			/**

    795. 

  795. 			 * Carga de multiples ficheros. Operacion no soportada.

    796. 

  796. 			 * Implementada en el applet Java de firma.

    797. 

  797. 			 */

    798. 

  798. 			this.getMultiFileNameContentBase64 = function(title, extensions, description) {

    799. 

  799. 				this.throwException(UnsupportedOperationException, "La operacion de carga de multiples ficheros no esta soportada");

    800. 

  800. 			};

    801. 

  801. 

    802. 

  802. 			/** 

    803. 

  803. 			 * Funcion para la comprobacion de existencia del objeto. No hace nada.

    804. 

  804. 			 * Implementada en el applet Java de firma.

    805. 

  805. 			 */

    806. 

  806. 			this.echo = function() {

    807. 

  807. 				return "Cliente JavaScript";

    808. 

  808. 			};

    809. 

  809. 

    810. 

  810. 			/** 

    811. 

  811. 			 * No hace nada.

    812. 

  812. 			 * Implementada en el applet Java de firma.

    813. 

  813. 			 */

    814. 

  814. 			this.setStickySignatory = function(sticky) {

    815. 

  815. 				// No hace nada

    816. 

  816. 			};

    817. 

  817. 			

    818. 

  818. 			/**

    819. 

  819. 			 * Recupera el mensaje de error asociado al ultimo error capturado.

    820. 

  820. 			 * Implementada en el applet Java de firma.

    821. 

  821. 			 */

    822. 

  822. 			this.getErrorMessage = function() {

    823. 

  823. 				return this.errorMessage;

    824. 

  824. 			};

    825. 

  825. 

    826. 

  826. 			/**

    827. 

  827. 			 * Recupera el tipo del ultimo error capturado.

    828. 

  828. 			 * Implementada en el applet Java de firma.

    829. 

  829. 			 */

    830. 

  830. 			this.getErrorType = function() {

    831. 

  831. 				return this.errorType;

    832. 

  832. 			};

    833. 

  833. 

    834. 

  834. 			/**

    835. 

  835. 			 * Recupera el log de la aplicacion. Actualmente, el log solo esta

    836. 

  836. 			 * disponible en el applet, no en las aplicacion moviles.

    837. 

  837. 			 */

    838. 

  838. 			this.getCurrentLog = function() {

    839. 

  839. 				return "Applet no cargado";

    840. 

  840. 			};

    841. 

  841. 

    842. 

  842. 			/**

    843. 

  843. 			 * Funcion para identificar el tipo de objeto del Cliente (javascript, applet,...).

    844. 

  844. 			 */

    845. 

  845. 			this.getType = function() {

    846. 

  846. 				return "javascript";

    847. 

  847. 			};

    848. 

  848. 

    849. 

  849. 			/**

    850. 

  850. 			 * Establece las rutas de los servlets encargados de almacenar y recuperar las firmas de los dispositivos moviles.

    851. 

  851. 			 */

    852. 

  852. 			this.setServlets = function(storageServlet,  retrieverServlet) {

    853. 

  853. 				this.storageServletAddress = storageServlet;

    854. 

  854. 				this.retrieverServletAddress = retrieverServlet;

    855. 

  855. 			};

    856. 

  856. 

    857. 

  857. 			/**

    858. 

  858. 			 * Establece el error indicado como error interno y lanza una excepcion.

    859. 

  859. 			 */

    860. 

  860. 			this.throwException = function(type, message) {

    861. 

  861. 				this.errorType = type;

    862. 

  862. 				this.errorMessage = message;

    863. 

  863. 				throw new Exception();

    864. 

  864. 			};

    865. 

  865. 

    866. 

  866. 			// Constants

    867. 

  867. 			var MAX_NUMBER = 2147483648;

    868. 

  868. 

    869. 

  869. 			// Pure javascript functions

    870. 

  870. 			function zeroFill(number, width) {

    871. 

  871. 				width -= number.toString().length;

    872. 

  872. 				if (width > 0) {

    873. 

  873. 					return new Array(width + (/\./.test(number) ? 2 : 1)).join('0')

    874. 

  874. 					+ number;

    875. 

  875. 				}

    876. 

  876. 				return number + ""; // Always return a string

    877. 

  877. 			}

    878. 

  878. 

    879. 

  879. 

    880. 

  880. 			/**

    881. 

  881. 			 * Funciones auxiliares del objeto JS del cliente de firma.

    882. 

  882. 			 **/

    883. 

  883. 			function generateNewIdSession() {

    884. 

  884. 				return zeroFill(Math.floor((Math.random() * MAX_NUMBER) + 1), 12);

    885. 

  885. 			}

    886. 

  886. 

    887. 

  887. 			var EXPAND_POLICIY_KEY_AND_VALUE = "expPolicy=FirmaAGE";

    888. 

  888. 			

    889. 

  889. 			/**

    890. 

  890. 			 * Identifica si debe expandirse la propiedad de politica de firma.

    891. 

  891. 			 * @param config Configuracion de la firma.

    892. 

  892. 			 * @returns Indica con true si debe expandirse el parametro de politica, false en caso contrario.

    893. 

  893. 			 */

    894. 

  894. 			function isPolicyConfigurated(config) {

    895. 

  895. 				return (config != undefined && config != null) ?

    896. 

  896. 					config.indexOf(EXPAND_POLICIY_KEY_AND_VALUE) > -1 : false;

    897. 

  897. 			}

    898. 

  898. 			

    899. 

  899. 			/**

    900. 

  900. 			 * Expande la variable de firma politica de firma si la encuentra en los extra params.

    901. 

  901. 			 **/

    902. 

  902. 			function expandPolicy(format, config) {

    903. 

  903. 				var expandedPolicy = "";

    904. 

  904. 				if (compareFormats(format, "CAdES")) {

    905. 

  905. 					expandedPolicy = "policyIdentifier=urn:oid:2.16.724.1.3.1.1.2.1.8\n" +

    906. 

  906. 						"policyQualifier=http://administracionelectronica.gob.es/es/ctt/politicafirma/politica_firma_AGE_v1_8.pdf\n" +

    907. 

  907. 						"policyIdentifierHashAlgorithm=http://www.w3.org/2000/09/xmldsig#sha1\n" +

    908. 

  908. 						"policyIdentifierHash=7SxX3erFuH31TvAw9LZ70N7p1vA=";

    909. 

  909. 				}

    910. 

  910. 				else if (compareFormats(format, "XAdES")) {

    911. 

  911. 					expandedPolicy = "policyIdentifier=urn:oid:2.16.724.1.3.1.1.2.1.8\n" +

    912. 

  912. 					"policyQualifier=http://administracionelectronica.gob.es/es/ctt/politicafirma/politica_firma_AGE_v1_8.pdf\n" +

    913. 

  913. 					"policyIdentifierHashAlgorithm=http://www.w3.org/2000/09/xmldsig#sha1\n" +

    914. 

  914. 					"policyIdentifierHash=V8lVVNGDCPen6VELRD1Ja8HARFk=";

    915. 

  915. 				}

    916. 

  916. //				else if (compareFormats(format, "PAdES") || compareFormats(format, "PDF")) {

    917. 

  917. //					// NO DISPONIBLE HASTA LA VERSION 1.9 DE LA POLITICA

    918. 

  918. //				expandedPolicy = "policyIdentifier=urn:oid:2.16.724.1.3.1.1.2.1.8\n" +

    919. 

  919. //				"policyQualifier=http://administracionelectronica.gob.es/es/ctt/politicafirma/politica_firma_AGE_v1_8.pdf\n" +

    920. 

  920. //				"policyIdentifierHashAlgorithm=http://www.w3.org/2000/09/xmldsig#sha1\n" +

    921. 

  921. //				"policyIdentifierHash=7SxX3erFuH31TvAw9LZ70N7p1vA=";

    922. 

  922. //				}

    923. 

  923. 

    924. 

  924. 				if (expandedPolicy != "") {

    925. 

  925. 					config = config.replace(EXPAND_POLICIY_KEY_AND_VALUE, expandedPolicy);

    926. 

  926. 				}

    927. 

  927. 				return config;

    928. 

  928. 			}

    929. 

  929. 			

    930. 

  930. 			/**

    931. 

  931. 			 * Compara que un nombre de formato sea equivalente a un formato de firma monofasico.

    932. 

  932. 			 * Por ejemplo, que XAdEStri sea igual a XAdES.

    933. 

  933. 			 **/

    934. 

  934. 			function compareFormats(format, supportedFormat) {

    935. 

  935. 				format = format.toUpperCase();

    936. 

  936. 				supportedFormat = supportedFormat.toUpperCase();

    937. 

  937. 				return format == supportedFormat ||

    938. 

  938. 						(format.length > supportedFormat.length &&

    939. 

  939. 								format.substr(0, supportedFormat.length) == supportedFormat);

    940. 

  940. 			}

    941. 

  941. 			

    942. 

  942. 			/**

    943. 

  943. 			 * Invoca un Intent con la operacion seleccionada, la configuraci\u00F3n establecida y las campos del

    944. 

  944. 			 * formulario pasado como parametro. Si se define un callback para tratar el caso de exito o error de

    945. 

  945. 			 * la operacion, se intentara descargar el resultado devuelto por la app del servidor intermedio de

    946. 

  946. 			 * comunicacion. 

    947. 

  947. 			 *

    948. 

  948. 			 * intentURL: URL para la invocacion del Cliente JavaScript

    949. 

  949. 			 * idSession: Identificador de la sesi\u00F3n para la recuperaci\u00F3n del resultado.

    950. 

  950. 			 * cipherKey: Clave de cifrado para la respuesta del servidor.

    951. 

  951. 			 * successCallback: Actuaci\u00F3n a realizar cuando se recupera el resultado de la operaci&oacute;n.

    952. 

  952. 			 * errorCallback: Actuaci\u00F3n a realizar cuando ocurre un error al recuperar el resultado.

    953. 

  953. 			 */

    954. 

  954. 			this.execAppIntent = function (intentURL, idSession, cipherKey, successCallback, errorCallback) {

    955. 

  955. 

    956. 

  956. 				// Invocamos al cliente de firma movil.

    957. 

  957. 				this.openUrl(intentURL);

    958. 

  958. 

    959. 

  959. 				if (successCallback != null || errorCallback != null) {

    960. 

  960. 					if (idSession != null && idSession != undefined && 

    961. 

  961. 							((successCallback != undefined && successCallback != null) ||

    962. 

  962. 									(errorCallback != undefined && errorCallback != null))) {

    963. 

  963. 						this.getStoredFileFromServlet(idSession, this.retrieverServletAddress, cipherKey, successCallback, errorCallback);

    964. 

  964. 					}

    965. 

  965. 				}

    966. 

  966. 			};

    967. 

  967. 

    968. 

  968. 			/**

    969. 

  969. 			 * Construye una URL para la invocaci&oacute;n del Cliente @firma nativo.

    970. 

  970. 			 *

    971. 

  971. 			 * op: Funcion a invocar en el cliente nativo.

    972. 

  972. 			 * params: Par\u00E1metros para la configuraci\u00F3n de la operaci\u00F3n.

    973. 

  973. 			 */

    974. 

  974. 			this.buildUrl = function(op, params) {

    975. 

  975. 

    976. 

  976. 				// Operacion seleccionada

    977. 

  977. 				var intentURL = this.getProtocol() + '://' + op + '?';

    978. 

  978. 				if (params != null && params != undefined) {

    979. 

  979. 					for (var i = 0; i < params.length; i++) {

    980. 

  980. 						intentURL += (i != 0 ? '&' : '') + params[i].key + '=' + params[i].value; 

    981. 

  981. 					}

    982. 

  982. 				}

    983. 

  983. 

    984. 

  984. 				return intentURL;

    985. 

  985. 			};

    986. 

  986. 			

    987. 

  987. 			this.getProtocol = function () {

    988. 

  988. 				// En Windows 8, siempre usaremos el modo "afirmametro", ya que por ahora

    989. 

  989. 				// la aplicacion con el protocolo "afirma" no hay otro disponible

    990. 

  990. 				if (MiniApplet.isWindows8()) {

    991. 

  991. 					return "afirmametro";

    992. 

  992. 				}

    993. 

  993. 				return "afirma";

    994. 

  994. 			};

    995. 

  995. 			

    996. 

  996. 			/**

    997. 

  997. 			 * Generan un XML con los datos de configuracion de la operacion indicada,

    998. 

  998. 			 * los cifra y lo envia a un servidor para su descarga.

    999. 

  999. 			 * @param cipherKey Clave de cifrado. Si no se indica, no se cifra.

    1000. 

  1000. 			 * @param storageServletAddress URL del servlet que almacena.

    1001. 

  1001. 			 * @param op Operacion que se configura.

    1002. 

  1002. 			 * @param params Parametros de configuracion de la operacion 

    1003. 

  1003. 			 * @returns El identificador con el que se ha guardado el fichero en servidor o false

    1004. 

  1004. 			 * si se produjo algun error.  

    1005. 

  1005. 			 */

    1006. 

  1006. 			this.preProccessData = function (cipherKey, storageServletAddress, op, params) {

    1007. 

  1007. 

    1008. 

  1008. 				// Identificador del fichero (equivalente a un id de sesion) del que deben recuperarse los datos

    1009. 

  1009. 				var fileId = generateNewIdSession(); 

    1010. 

  1010. 

    1011. 

  1011. 				var httpRequest = getHttpRequest();

    1012. 

  1012. 				if (!httpRequest) {

    1013. 

  1013. 					this.throwException("java.lang.Exception", "Su navegador no permite preprocesar los datos que desea tratar");

    1014. 

  1014. 				}

    1015. 

  1015. 

    1016. 

  1016. 				var cipheredDataB64 = cipher(buildXML(op, params), cipherKey);

    1017. 

  1017. 

    1018. 

  1018. 				httpRequest.open("POST", storageServletAddress, false);

    1019. 

  1019. 				httpRequest.setRequestHeader("Content-type","application/x-www-form-urlencoded");

    1020. 

  1020. 				try {

    1021. 

  1021. 					httpRequest.send("op=put&v=1_0&id=" + fileId + "&dat=" + cipheredDataB64);

    1022. 

  1022. 				}

    1023. 

  1023. 				catch(e) {

    1024. 

  1024. 					this.errorMessage = "No se pudo conectar con el servidor remoto";

    1025. 

  1025. 					this.errorType = "java.io.IOException";

    1026. 

  1026. 				}

    1027. 

  1027. 				

    1028. 

  1028. 				if (httpRequest.readyState==4 && httpRequest.status==200) {

    1029. 

  1029. 					return fileId;	

    1030. 

  1030. 				}

    1031. 

  1031. 

    1032. 

  1032. 				return false;

    1033. 

  1033. 			};

    1034. 

  1034. 

    1035. 

  1035. 			/**

    1036. 

  1036. 			 * Construye un XML con lo valores del array de parametros proporcionado.

    1037. 

  1037. 			 * @param op Operacion que configuramos

    1038. 

  1038. 			 * @param params Array con los parametros del array. 

    1039. 

  1039. 			 * @returns XML.

    1040. 

  1040. 			 */

    1041. 

  1041. 			function buildXML (op, params) {

    1042. 

  1042. 				op = (op == null ? "op" : op);

    1043. 

  1043. 				var xml = '<' + op +'>';

    1044. 

  1044. 				for (var i = 0; i < params.length; i++) {

    1045. 

  1045. 					xml += '<e k="' + params[i].key + '" v="' + params[i].value + '"/>';

    1046. 

  1046. 				}

    1047. 

  1047. 				return Base64.encode(xml + '</' + op + '>');

    1048. 

  1048. 			};

    1049. 

  1049. 

    1050. 

  1050. 			/**

    1051. 

  1051. 			 * Crea una URL a partir de los parametros introducidos para la invocaci&oacute;n de

    1052. 

  1052. 			 * una app nativa para que descargue la configuracion de la operaci&oacute;n a realizar.

    1053. 

  1053. 			 * @param op Codigo de la operacion a la que tiene que invocar la URL.

    1054. 

  1054. 			 * @param id Identificador para la descarga.

    1055. 

  1055. 			 * @param rtServlet Servlet para la descarga de la configuraci&oacute;n.

    1056. 

  1056. 			 * @param cipherKey Clave para el descifrado.

    1057. 

  1057. 			 * @returns URL para la llamada a la app con los datos necesarios para que descargue

    1058. 

  1058. 			 * la configuraci&oacute;n de la operaci&oacute;n a realizar.

    1059. 

  1059. 			 */

    1060. 

  1060. 			this.buildUrlWithoutData = function (op, id, rtServlet, cipherKey) {

    1061. 

  1061. 				var j = 0;

    1062. 

  1062. 				var newParams = new Array();

    1063. 

  1063. 				newParams[j++] = {key:"fileid", value:id};

    1064. 

  1064. 				if (rtServlet != null || rtServlet != undefined) {

    1065. 

  1065. 					newParams[j++] = {key:"rtservlet", value:rtServlet};

    1066. 

  1066. 				}

    1067. 

  1067. 				if (cipherKey != null || cipherKey != undefined) {

    1068. 

  1068. 					newParams[j++] = {key:"key", value:cipherKey};

    1069. 

  1069. 				}

    1070. 

  1070. 				return this.buildUrl(op, newParams);

    1071. 

  1071. 			};

    1072. 

  1072. 

    1073. 

  1073. 			/**

    1074. 

  1074. 			 * Llama a la aplicacion de firma a traves de la URL de invocacion sin que afecte

    1075. 

  1075. 			 * a la pagina que se esta mostrando.

    1076. 

  1076. 			 * @param url URL de invocacion.

    1077. 

  1077. 			 */

    1078. 

  1078. 			this.openUrl = function (url) {

    1079. 

  1079. 				

    1080. 

  1080. 				// Usamos document.location porque tiene mejor soporte por los navegadores que

    1081. 

  1081. 				// window.location que es el mecanismo estandar

    1082. 

  1082. 				if (MiniApplet.isChrome()) {

    1083. 

  1083. 					document.location = url;

    1084. 

  1084. 				}

    1085. 

  1085. 				else {

    1086. 

  1086. 					var iframeElem = document.createElement("iframe");

    1087. 

  1087. 					

    1088. 

  1088. 					var srcAttr = document.createAttribute("src");

    1089. 

  1089. 					srcAttr.value = url;

    1090. 

  1090. 					iframeElem.setAttributeNode(srcAttr);

    1091. 

  1091. 					

    1092. 

  1092. 					var heightAttr = document.createAttribute("height");

    1093. 

  1093. 					heightAttr.value = 1;

    1094. 

  1094. 					iframeElem.setAttributeNode(heightAttr);

    1095. 

  1095. 					

    1096. 

  1096. 					var widthAttr = document.createAttribute("width");

    1097. 

  1097. 					widthAttr.value = 1;

    1098. 

  1098. 					iframeElem.setAttributeNode(widthAttr);

    1099. 

  1099. 					

    1100. 

  1100. 					var seamlessAttr = document.createAttribute("seamless");

    1101. 

  1101. 					seamlessAttr.value = "seamless";

    1102. 

  1102. 					iframeElem.setAttributeNode(seamlessAttr);

    1103. 

  1103. 					

    1104. 

  1104. 					document.body.appendChild(iframeElem);

    1105. 

  1105. 				}

    1106. 

  1106. 			};

    1107. 

  1107. 

    1108. 

  1108. 			var iterations = 0;

    1109. 

  1109. 

    1110. 

  1110. 			/**

    1111. 

  1111. 			 * Ejecuta el metodo de error si el html recuperado es tal o el metodo de exito si no lo es,

    1112. 

  1112. 			 * en cuyo caso previamente descifrara el resultado. 

    1113. 

  1113. 			 * @param html Resultado obtenido.

    1114. 

  1114. 			 * @param cipherKey Clave para el descifrado del resultado si no es un error.

    1115. 

  1115. 			 * @param successCallback Metodo a ejecutar en caso de exito.

    1116. 

  1116. 			 * @param errorCallback Metodo a ejecutar en caso de error.

    1117. 

  1117. 			 * @returns Devuelve true si se ha fallado pero se puede volver a reintentar, false en caso de

    1118. 

  1118. 			 * error determinante o exito.

    1119. 

  1119. 			 */

    1120. 

  1120. 			this.successResponseFunction = function(html, cipherKey, successCallback, errorCallback) {

    1121. 

  1121. 

    1122. 

  1122. 				// Si se obtiene el mensaje de  error de que el identificador no existe, seguimos intentandolo

    1123. 

  1123. 				if (html.substr(0, 6).toLowerCase() == "err-06") {

    1124. 

  1124. 					return true;

    1125. 

  1125. 				}

    1126. 

  1126. 

    1127. 

  1127. 				// Si se obtiene otro mensaje de error, se deja de intentar y se ejecuta la funcion callback de error

    1128. 

  1128. 				if (html.substr(0, 4).toLowerCase() == "err-" && html.indexOf(":=") != -1) {

    1129. 

  1129. 					this.errorMessage = html.substring(html.indexOf(":=") + 2);

    1130. 

  1130. 					this.errorType = "java.lang.Exception";

    1131. 

  1131. 					errorCallback(this.errorType, this.errorMessage);

    1132. 

  1132. 					return false;

    1133. 

  1133. 				}

    1134. 

  1134. 

    1135. 

  1135. 				// Si no se obtuvo un error y se definio una clave de cifrado privada, desciframos.

    1136. 

  1136. 				// Los datos cifrados van precedidos por la cantidad de caracteres agregados manualmente al final para

    1137. 

  1137. 				// cumplir con los requisitos de padding del algoritmo de cifrado. Este numero se separa de la cadena

    1138. 

  1138. 				// cifrada con el caracter '.'. Devuelve el resultado del descifrado en Base64.

    1139. 

  1139. 				if (cipherKey != undefined && cipherKey != null) {

    1140. 

  1140. 					html = decipher(html, cipherKey);

    1141. 

  1141. 				}

    1142. 

  1142. 				

    1143. 

  1143. 				// Ejecutamos la funcion callback de exito y notificamos que se dejen de realizar peticiones

    1144. 

  1144. 				successCallback(html);

    1145. 

  1145. 				

    1146. 

  1146. 				return false;

    1147. 

  1147. 			};

    1148. 

  1148. 

    1149. 

  1149. 			this.errorResponseFunction = function(type, message, errorCallback) {

    1150. 

  1150. 

    1151. 

  1151. 				this.errorType = (type != null && type.length > 0) ?

    1152. 

  1152. 						type : "java.lang.Exception";

    1153. 

  1153. 				this.errorMessage = (message != null && message.length > 0) ?

    1154. 

  1154. 						message : "No se ha podido extablecer la comunicaci\u00F3n entre la aplicaci\u00F3n de firma y la p\u00E1gina web";

    1155. 

  1155. 				errorCallback(this.errorType, this.errorMessage);

    1156. 

  1156. 			};

    1157. 

  1157. 

    1158. 

  1158. 

    1159. 

  1159. 			this.getStoredFileFromServlet = function (idDocument, servletAddress, cipherKey, successCallback, errorCallback) {

    1160. 

  1160. 

    1161. 

  1161. 				var httpRequest = getHttpRequest();

    1162. 

  1162. 				if (!httpRequest) {

    1163. 

  1163. 					this.throwException("java.lang.Exception", "Su navegador no permite obtener el resulado de la operaci\u00F3n");

    1164. 

  1164. 				}

    1165. 

  1165. 

    1166. 

  1166. 				iterations = 0;

    1167. 

  1167. 				setTimeout(retrieveRequest, 4000, httpRequest, servletAddress, "op=get&v=1_0&id=" + idDocument + "&it=0", cipherKey, successCallback, errorCallback);

    1168. 

  1168. 			};

    1169. 

  1169. 

    1170. 

  1170. 			var NUM_MAX_ITERATIONS = 15;

    1171. 

  1171. 

    1172. 

  1172. 			function retrieveRequest(httpRequest, url, params, cipherKey, successCallback, errorCallback) {

    1173. 

  1173. 

    1174. 

  1174. 				// Contamos la nueva llamada al servidor

    1175. 

  1175. 				if (iterations > NUM_MAX_ITERATIONS) {

    1176. 

  1176. 					MiniApplet.clienteFirma.errorResponseFunction("java.util.concurrent.TimeoutException", "El tiempo para la recepcion de la firma por la pagina web ha expirado", errorCallback);

    1177. 

  1177. 					return;

    1178. 

  1178. 				}

    1179. 

  1179. 				iterations++;

    1180. 

  1180. 

    1181. 

  1181. 				//TODO: Separar parametros

    1182. 

  1182. 				httpRequest.open("POST", url, false);

    1183. 

  1183. 				httpRequest.setRequestHeader("Content-type","application/x-www-form-urlencoded");

    1184. 

  1184. 

    1185. 

  1185. 				try {

    1186. 

  1186. 					httpRequest.send(params);

    1187. 

  1187. 				}

    1188. 

  1188. 				catch(e) {

    1189. 

  1189. 					// Error en la llamada para al recuperacion del resultado. No lo encuentra o problema

    1190. 

  1190. 					// de tipo cross-domain

    1191. 

  1191. 					MiniApplet.clienteFirma.errorResponseFunction("java.lang.IOException", "Ocurrio un error de red en la llamada al servicio de firma", errorCallback);

    1192. 

  1192. 					return;

    1193. 

  1193. 				}

    1194. 

  1194. 

    1195. 

  1195. 				if (httpRequest.readyState==4) {

    1196. 

  1196. 					if (httpRequest.status==200) {

    1197. 

  1197. 						var needContinue = MiniApplet.clienteFirma.successResponseFunction(httpRequest.responseText, cipherKey, successCallback, errorCallback);

    1198. 

  1198. 						if (!needContinue) {

    1199. 

  1199. 							return;

    1200. 

  1200. 						}

    1201. 

  1201. 					}

    1202. 

  1202. 					else {

    1203. 

  1203. 						MiniApplet.clienteFirma.errorResponseFunction(null, httpRequest.responseText, errorCallback);

    1204. 

  1204. 						return;

    1205. 

  1205. 					}

    1206. 

  1206. 				}

    1207. 

  1207. 

    1208. 

  1208. 				setTimeout(retrieveRequest, 4000, httpRequest, url, params.replace("&it=" + (iterations-1), "&it=" + iterations), cipherKey, successCallback, errorCallback);

    1209. 

  1209. 			}

    1210. 

  1210. 

    1211. 

  1211. 			// getHttpRequest

    1212. 

  1212. 			function getHttpRequest() {

    1213. 

  1213. 				var activexmodes=["Msxml2.XMLHTTP", "Microsoft.XMLHTTP"]; //activeX versions to check for in IE

    1214. 

  1214. 				if (window.ActiveXObject){ //Test for support for ActiveXObject in IE first (as XMLHttpRequest in IE7 is broken)

    1215. 

  1215. 					for (var i=0; i<activexmodes.length; i++) {

    1216. 

  1216. 						try {

    1217. 

  1217. 							return new ActiveXObject(activexmodes[i]);

    1218. 

  1218. 						}

    1219. 

  1219. 						catch(e) {

    1220. 

  1220. 							//suppress error

    1221. 

  1221. 						}

    1222. 

  1222. 					}

    1223. 

  1223. 				}

    1224. 

  1224. 				else if (window.XMLHttpRequest) { // if Mozilla, Safari etc

    1225. 

  1225. 					return new XMLHttpRequest();

    1226. 

  1226. 				}

    1227. 

  1227. 				else {

    1228. 

  1228. 					return false;

    1229. 

  1229. 				}

    1230. 

  1230. 			}

    1231. 

  1231. 

    1232. 

  1232. 			/**

    1233. 

  1233. 			 * Genera un numero aleatorio para utilizar como clave de cifrado.

    1234. 

  1234. 			 */

    1235. 

  1235. 			function generateCipherKey() {

    1236. 

  1236. 				return zeroFill(Math.floor(((Math.random() * MAX_NUMBER) + 1) % 100000000), 8);

    1237. 

  1237. 			}

    1238. 

  1238. 

    1239. 

  1239. 			/**

    1240. 

  1240. 			 * Realiza un descifrado DES compatible con Java (Algoritmo DES, modo CBC, sin Padding).

    1241. 

  1241. 			 * Recibe en base 64 la cadena de texto cifrado antecedido por el padding anadido manualmente

    1242. 

  1242. 			 * a los datos para permitir el cifrado DES (separado por un punto ('.')), ademas de la clave

    1243. 

  1243. 			 * para descifrar.

    1244. 

  1244. 			 * Como resultado devuelve la cadena de texto descifrada en base 64.

    1245. 

  1245. 			 */

    1246. 

  1246. 			function decipher(cipheredData, key) {

    1247. 

  1247. 								

    1248. 

  1248. 				var dotPos = cipheredData.indexOf('.');

    1249. 

  1249. 				var padding = cipheredData.substr(0, dotPos);

    1250. 

  1250. 				

    1251. 

  1251. 				var deciphered = des(key, base64ToString(cipheredData.substr(dotPos + 1).replace(/\-/g, "+").replace(/\_/g, "/")), 0, 0, null);

    1252. 

  1252. 				

    1253. 

  1253. 				return stringToBase64(deciphered.substr(0, deciphered.length - padding - 8));

    1254. 

  1254. 			}

    1255. 

  1255. 			

    1256. 

  1256. 			/**

    1257. 

  1257. 			 * Realiza un cifrado DES compatible con Java (Algoritmo DES, modo CBC, sin Padding).

    1258. 

  1258. 			 * @param dataB64 Cadena de texto base 64.

    1259. 

  1259. 			 * @param key Clave de cifrado.

    1260. 

  1260. 			 * @return Base 64 cifrado.

    1261. 

  1261. 			 */

    1262. 

  1262. 			function cipher(dataB64, key) {

    1263. 

  1263. 

    1264. 

  1264. 				var data = base64ToString(dataB64.replace(/\-/g, "+").replace(/\_/g, "/"));

    1265. 

  1265. 				var padding = (8 - (data.length % 8)) % 8;

    1266. 

  1266. 				

    1267. 

  1267. 				// Los datos cifrados los pasamos a base 64 y, antes de devolverlos le anteponemos el padding que

    1268. 

  1268. 				// le habra agregado el metodo de cifrado separados por un punto ('.').

    1269. 

  1269. 				return padding  + "." + stringToBase64(des(key, data, 1, 0, null)).replace(/\+/g, "-").replace(/\//g, "_");

    1270. 

  1270. 			}

    1271. 

  1271. 		}

    1272. 

  1272. };

    1273. 

  1273. 

    1274. 

  1274. 

    1275. 

  1275. 

    1276. 

  1276. 

    1277. 

  1277. 

    1278. 

  1278. /**

    1279. 

  1279.  *  Base64 encode / decode

    1280. 

  1280.  *  http://www.webtoolkit.info/

    1281. 

  1281.  */

    1282. 

  1282. var Base64 = {

    1283. 

  1283. 

    1284. 

  1284. 		// private property

    1285. 

  1285. 		_keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",

    1286. 

  1286. 		_keyStr_URL_SAFE : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",

    1287. 

  1287. 

    1288. 

  1288. 		// public method for encoding

    1289. 

  1289. 		encode : function (input, URL_SAFE) {

    1290. 

  1290. 			

    1291. 

  1291. 			var keyStr = (URL_SAFE == true) ? this._keyStr_URL_SAFE : this._keyStr;

    1292. 

  1292. 			

    1293. 

  1293. 			var output = "";

    1294. 

  1294. 			var chr1, chr2, chr3, enc1, enc2, enc3, enc4;

    1295. 

  1295. 			var i = 0;

    1296. 

  1296. 

    1297. 

  1297. 			input = Base64._utf8_encode(input);

    1298. 

  1298. 

    1299. 

  1299. 			while (i < input.length) {

    1300. 

  1300. 

    1301. 

  1301. 				chr1 = input.charCodeAt(i++);

    1302. 

  1302. 				chr2 = input.charCodeAt(i++);

    1303. 

  1303. 				chr3 = input.charCodeAt(i++);

    1304. 

  1304. 

    1305. 

  1305. 				enc1 = chr1 >> 2;

    1306. 

  1306. 				enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);

    1307. 

  1307. 				enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);

    1308. 

  1308. 				enc4 = chr3 & 63;

    1309. 

  1309. 

    1310. 

  1310. 				if (isNaN(chr2)) {

    1311. 

  1311. 					enc3 = enc4 = 64;

    1312. 

  1312. 				} else if (isNaN(chr3)) {

    1313. 

  1313. 					enc4 = 64;

    1314. 

  1314. 				}

    1315. 

  1315. 

    1316. 

  1316. 				output = output +

    1317. 

  1317. 				keyStr.charAt(enc1) + keyStr.charAt(enc2) +

    1318. 

  1318. 				keyStr.charAt(enc3) + keyStr.charAt(enc4);

    1319. 

  1319. 

    1320. 

  1320. 			}

    1321. 

  1321. 

    1322. 

  1322. 			return output;

    1323. 

  1323. 		},

    1324. 

  1324. 

    1325. 

  1325. 		// public method for decoding

    1326. 

  1326. 		decode : function (input, URL_SAFE) {

    1327. 

  1327. 			

    1328. 

  1328. 			var keyStr = (URL_SAFE == true) ? this._keyStr_URL_SAFE : this._keyStr;

    1329. 

  1329. 			

    1330. 

  1330. 			var output = "";

    1331. 

  1331. 			var chr1, chr2, chr3;

    1332. 

  1332. 			var enc1, enc2, enc3, enc4;

    1333. 

  1333. 			var i = 0;

    1334. 

  1334. 

    1335. 

  1335. 			input = (URL_SAFE == true) ? input.replace(/[^A-Za-z0-9\-\_\=]/g, "") : input.replace(/[^A-Za-z0-9\+\/\=]/g, "");

    1336. 

  1336. 

    1337. 

  1337. 			while (i < input.length) {

    1338. 

  1338. 

    1339. 

  1339. 				enc1 = keyStr.indexOf(input.charAt(i++));

    1340. 

  1340. 				enc2 = keyStr.indexOf(input.charAt(i++));

    1341. 

  1341. 				enc3 = keyStr.indexOf(input.charAt(i++));

    1342. 

  1342. 				enc4 = keyStr.indexOf(input.charAt(i++));

    1343. 

  1343. 

    1344. 

  1344. 				chr1 = (enc1 << 2) | (enc2 >> 4);

    1345. 

  1345. 				chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);

    1346. 

  1346. 				chr3 = ((enc3 & 3) << 6) | enc4;

    1347. 

  1347. 

    1348. 

  1348. 				output = output + String.fromCharCode(chr1);

    1349. 

  1349. 

    1350. 

  1350. 				if (enc3 != 64) {

    1351. 

  1351. 					output = output + String.fromCharCode(chr2);

    1352. 

  1352. 				}

    1353. 

  1353. 				if (enc4 != 64) {

    1354. 

  1354. 					output = output + String.fromCharCode(chr3);

    1355. 

  1355. 				}

    1356. 

  1356. 

    1357. 

  1357. 			}

    1358. 

  1358. 

    1359. 

  1359. 			output = Base64._utf8_decode(output);

    1360. 

  1360. 

    1361. 

  1361. 			return output;

    1362. 

  1362. 

    1363. 

  1363. 		},

    1364. 

  1364. 

    1365. 

  1365. 		// private method for UTF-8 encoding

    1366. 

  1366. 		_utf8_encode : function (string) {

    1367. 

  1367. 			string = string.replace(/\r\n/g,"\n");

    1368. 

  1368. 			var utftext = "";

    1369. 

  1369. 

    1370. 

  1370. 			for (var n = 0; n < string.length; n++) {

    1371. 

  1371. 

    1372. 

  1372. 				var c = string.charCodeAt(n);

    1373. 

  1373. 

    1374. 

  1374. 				if (c < 128) {

    1375. 

  1375. 					utftext += String.fromCharCode(c);

    1376. 

  1376. 				}

    1377. 

  1377. 				else if((c > 127) && (c < 2048)) {

    1378. 

  1378. 					utftext += String.fromCharCode((c >> 6) | 192);

    1379. 

  1379. 					utftext += String.fromCharCode((c & 63) | 128);

    1380. 

  1380. 				}

    1381. 

  1381. 				else {

    1382. 

  1382. 					utftext += String.fromCharCode((c >> 12) | 224);

    1383. 

  1383. 					utftext += String.fromCharCode(((c >> 6) & 63) | 128);

    1384. 

  1384. 					utftext += String.fromCharCode((c & 63) | 128);

    1385. 

  1385. 				}

    1386. 

  1386. 

    1387. 

  1387. 			}

    1388. 

  1388. 

    1389. 

  1389. 			return utftext;

    1390. 

  1390. 		},

    1391. 

  1391. 

    1392. 

  1392. 		// private method for UTF-8 decoding

    1393. 

  1393. 		_utf8_decode : function (utftext) {

    1394. 

  1394. 			var string = "";

    1395. 

  1395. 			var i = 0;

    1396. 

  1396. 			var c = c1 = c2 = 0;

    1397. 

  1397. 

    1398. 

  1398. 			while ( i < utftext.length ) {

    1399. 

  1399. 

    1400. 

  1400. 				c = utftext.charCodeAt(i);

    1401. 

  1401. 

    1402. 

  1402. 				if (c < 128) {

    1403. 

  1403. 					string += String.fromCharCode(c);

    1404. 

  1404. 					i++;

    1405. 

  1405. 				}

    1406. 

  1406. 				else if((c > 191) && (c < 224)) {

    1407. 

  1407. 					c2 = utftext.charCodeAt(i+1);

    1408. 

  1408. 					string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));

    1409. 

  1409. 					i += 2;

    1410. 

  1410. 				}

    1411. 

  1411. 				else {

    1412. 

  1412. 					c2 = utftext.charCodeAt(i+1);

    1413. 

  1413. 					c3 = utftext.charCodeAt(i+2);

    1414. 

  1414. 					string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));

    1415. 

  1415. 					i += 3;

    1416. 

  1416. 				}

    1417. 

  1417. 

    1418. 

  1418. 			}

    1419. 

  1419. 

    1420. 

  1420. 			return string;

    1421. 

  1421. 		}

    1422. 

  1422. 

    1423. 

  1423. };

    1424. 

  1424. 

    1425. 

  1425. //Paul Tero, July 2001

    1426. 

  1426. //http://www.tero.co.uk/des/

    1427. 

  1427. 

    1428. 

  1428. //Optimised for performance with large blocks by Michael Hayworth, November 2001

    1429. 

  1429. //http://www.netdealing.com

    1430. 

  1430. 

    1431. 

  1431. //THIS SOFTWARE IS PROVIDED "AS IS" AND

    1432. 

  1432. //ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    1433. 

  1433. //IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    1434. 

  1434. //ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

    1435. 

  1435. //FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    1436. 

  1436. //DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    1437. 

  1437. //OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    1438. 

  1438. //HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    1439. 

  1439. //LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    1440. 

  1440. //OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    1441. 

  1441. //SUCH DAMAGE.

    1442. 

  1442. 

    1443. 

  1443. //des

    1444. 

  1444. //this takes the key, the message, and whether to encrypt or decrypt

    1445. 

  1445. function des (key, message, encrypt, mode, iv, padding) {

    1446. 

  1446. 	  //declaring this locally speeds things up a bit

    1447. 

  1447. 	  var spfunction1 = new Array (0x1010400,0,0x10000,0x1010404,0x1010004,0x10404,0x4,0x10000,0x400,0x1010400,0x1010404,0x400,0x1000404,0x1010004,0x1000000,0x4,0x404,0x1000400,0x1000400,0x10400,0x10400,0x1010000,0x1010000,0x1000404,0x10004,0x1000004,0x1000004,0x10004,0,0x404,0x10404,0x1000000,0x10000,0x1010404,0x4,0x1010000,0x1010400,0x1000000,0x1000000,0x400,0x1010004,0x10000,0x10400,0x1000004,0x400,0x4,0x1000404,0x10404,0x1010404,0x10004,0x1010000,0x1000404,0x1000004,0x404,0x10404,0x1010400,0x404,0x1000400,0x1000400,0,0x10004,0x10400,0,0x1010004);

    1448. 

  1448. 	  var spfunction2 = new Array (-0x7fef7fe0,-0x7fff8000,0x8000,0x108020,0x100000,0x20,-0x7fefffe0,-0x7fff7fe0,-0x7fffffe0,-0x7fef7fe0,-0x7fef8000,-0x80000000,-0x7fff8000,0x100000,0x20,-0x7fefffe0,0x108000,0x100020,-0x7fff7fe0,0,-0x80000000,0x8000,0x108020,-0x7ff00000,0x100020,-0x7fffffe0,0,0x108000,0x8020,-0x7fef8000,-0x7ff00000,0x8020,0,0x108020,-0x7fefffe0,0x100000,-0x7fff7fe0,-0x7ff00000,-0x7fef8000,0x8000,-0x7ff00000,-0x7fff8000,0x20,-0x7fef7fe0,0x108020,0x20,0x8000,-0x80000000,0x8020,-0x7fef8000,0x100000,-0x7fffffe0,0x100020,-0x7fff7fe0,-0x7fffffe0,0x100020,0x108000,0,-0x7fff8000,0x8020,-0x80000000,-0x7fefffe0,-0x7fef7fe0,0x108000);

    1449. 

  1449. 	  var spfunction3 = new Array (0x208,0x8020200,0,0x8020008,0x8000200,0,0x20208,0x8000200,0x20008,0x8000008,0x8000008,0x20000,0x8020208,0x20008,0x8020000,0x208,0x8000000,0x8,0x8020200,0x200,0x20200,0x8020000,0x8020008,0x20208,0x8000208,0x20200,0x20000,0x8000208,0x8,0x8020208,0x200,0x8000000,0x8020200,0x8000000,0x20008,0x208,0x20000,0x8020200,0x8000200,0,0x200,0x20008,0x8020208,0x8000200,0x8000008,0x200,0,0x8020008,0x8000208,0x20000,0x8000000,0x8020208,0x8,0x20208,0x20200,0x8000008,0x8020000,0x8000208,0x208,0x8020000,0x20208,0x8,0x8020008,0x20200);

    1450. 

  1450. 	  var spfunction4 = new Array (0x802001,0x2081,0x2081,0x80,0x802080,0x800081,0x800001,0x2001,0,0x802000,0x802000,0x802081,0x81,0,0x800080,0x800001,0x1,0x2000,0x800000,0x802001,0x80,0x800000,0x2001,0x2080,0x800081,0x1,0x2080,0x800080,0x2000,0x802080,0x802081,0x81,0x800080,0x800001,0x802000,0x802081,0x81,0,0,0x802000,0x2080,0x800080,0x800081,0x1,0x802001,0x2081,0x2081,0x80,0x802081,0x81,0x1,0x2000,0x800001,0x2001,0x802080,0x800081,0x2001,0x2080,0x800000,0x802001,0x80,0x800000,0x2000,0x802080);

    1451. 

  1451. 	  var spfunction5 = new Array (0x100,0x2080100,0x2080000,0x42000100,0x80000,0x100,0x40000000,0x2080000,0x40080100,0x80000,0x2000100,0x40080100,0x42000100,0x42080000,0x80100,0x40000000,0x2000000,0x40080000,0x40080000,0,0x40000100,0x42080100,0x42080100,0x2000100,0x42080000,0x40000100,0,0x42000000,0x2080100,0x2000000,0x42000000,0x80100,0x80000,0x42000100,0x100,0x2000000,0x40000000,0x2080000,0x42000100,0x40080100,0x2000100,0x40000000,0x42080000,0x2080100,0x40080100,0x100,0x2000000,0x42080000,0x42080100,0x80100,0x42000000,0x42080100,0x2080000,0,0x40080000,0x42000000,0x80100,0x2000100,0x40000100,0x80000,0,0x40080000,0x2080100,0x40000100);

    1452. 

  1452. 	  var spfunction6 = new Array (0x20000010,0x20400000,0x4000,0x20404010,0x20400000,0x10,0x20404010,0x400000,0x20004000,0x404010,0x400000,0x20000010,0x400010,0x20004000,0x20000000,0x4010,0,0x400010,0x20004010,0x4000,0x404000,0x20004010,0x10,0x20400010,0x20400010,0,0x404010,0x20404000,0x4010,0x404000,0x20404000,0x20000000,0x20004000,0x10,0x20400010,0x404000,0x20404010,0x400000,0x4010,0x20000010,0x400000,0x20004000,0x20000000,0x4010,0x20000010,0x20404010,0x404000,0x20400000,0x404010,0x20404000,0,0x20400010,0x10,0x4000,0x20400000,0x404010,0x4000,0x400010,0x20004010,0,0x20404000,0x20000000,0x400010,0x20004010);

    1453. 

  1453. 	  var spfunction7 = new Array (0x200000,0x4200002,0x4000802,0,0x800,0x4000802,0x200802,0x4200800,0x4200802,0x200000,0,0x4000002,0x2,0x4000000,0x4200002,0x802,0x4000800,0x200802,0x200002,0x4000800,0x4000002,0x4200000,0x4200800,0x200002,0x4200000,0x800,0x802,0x4200802,0x200800,0x2,0x4000000,0x200800,0x4000000,0x200800,0x200000,0x4000802,0x4000802,0x4200002,0x4200002,0x2,0x200002,0x4000000,0x4000800,0x200000,0x4200800,0x802,0x200802,0x4200800,0x802,0x4000002,0x4200802,0x4200000,0x200800,0,0x2,0x4200802,0,0x200802,0x4200000,0x800,0x4000002,0x4000800,0x800,0x200002);

    1454. 

  1454. 	  var spfunction8 = new Array (0x10001040,0x1000,0x40000,0x10041040,0x10000000,0x10001040,0x40,0x10000000,0x40040,0x10040000,0x10041040,0x41000,0x10041000,0x41040,0x1000,0x40,0x10040000,0x10000040,0x10001000,0x1040,0x41000,0x40040,0x10040040,0x10041000,0x1040,0,0,0x10040040,0x10000040,0x10001000,0x41040,0x40000,0x41040,0x40000,0x10041000,0x1000,0x40,0x10040040,0x1000,0x41040,0x10001000,0x40,0x10000040,0x10040000,0x10040040,0x10000000,0x40000,0x10001040,0,0x10041040,0x40040,0x10000040,0x10040000,0x10001000,0x10001040,0,0x10041040,0x41000,0x41000,0x1040,0x1040,0x40040,0x10000000,0x10041000);

    1455. 

  1455. 

    1456. 

  1456. 	  //create the 16 or 48 subkeys we will need

    1457. 

  1457. 	  var keys = des_createKeys (key);

    1458. 

  1458. 	  var m=0, i, j, temp, right1, right2, left, right, looping;

    1459. 

  1459. 	  var cbcleft, cbcleft2, cbcright, cbcright2;

    1460. 

  1460. 	  var endloop, loopinc;

    1461. 

  1461. 	  var len = message.length;

    1462. 

  1462. 	  var chunk = 0;

    1463. 

  1463. 	  //set up the loops for single and triple des

    1464. 

  1464. 	  var iterations = keys.length == 32 ? 3 : 9; //single or triple des

    1465. 

  1465. 	  if (iterations == 3) {looping = encrypt ? new Array (0, 32, 2) : new Array (30, -2, -2);}

    1466. 

  1466. 	  else {looping = encrypt ? new Array (0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array (94, 62, -2, 32, 64, 2, 30, -2, -2);}

    1467. 

  1467. 

    1468. 

  1468. 	  //pad the message depending on the padding parameter

    1469. 

  1469. 	  if (padding == 2) message += "        "; //pad the message with spaces

    1470. 

  1470. 	  else if (padding == 1) {temp = 8-(len%8); message += String.fromCharCode (temp,temp,temp,temp,temp,temp,temp,temp); if (temp==8) len+=8;} //PKCS7 padding

    1471. 

  1471. 	  else if (!padding) message += "\0\0\0\0\0\0\0\0"; //pad the message out with null bytes

    1472. 

  1472. 

    1473. 

  1473. 	  //store the result here

    1474. 

  1474. 	  result = "";

    1475. 

  1475. 	  tempresult = "";

    1476. 

  1476. 

    1477. 

  1477. 	  if (mode == 1) { //CBC mode

    1478. 

  1478. 	    cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);

    1479. 

  1479. 	    cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);

    1480. 

  1480. 	    m=0;

    1481. 

  1481. 	  }

    1482. 

  1482. 

    1483. 

  1483. 	  //loop through each 64 bit chunk of the message

    1484. 

  1484. 	  while (m < len) {

    1485. 

  1485. 	    left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);

    1486. 

  1486. 	    right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);

    1487. 

  1487. 

    1488. 

  1488. 	    //for Cipher Block Chaining mode, xor the message with the previous result

    1489. 

  1489. 	    if (mode == 1) {if (encrypt) {left ^= cbcleft; right ^= cbcright;} else {cbcleft2 = cbcleft; cbcright2 = cbcright; cbcleft = left; cbcright = right;}}

    1490. 

  1490. 

    1491. 

  1491. 	    //first each 64 but chunk of the message must be permuted according to IP

    1492. 

  1492. 	    temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);

    1493. 

  1493. 	    temp = ((left >>> 16) ^ right) & 0x0000ffff; right ^= temp; left ^= (temp << 16);

    1494. 

  1494. 	    temp = ((right >>> 2) ^ left) & 0x33333333; left ^= temp; right ^= (temp << 2);

    1495. 

  1495. 	    temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);

    1496. 

  1496. 	    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);

    1497. 

  1497. 

    1498. 

  1498. 	    left = ((left << 1) | (left >>> 31)); 

    1499. 

  1499. 	    right = ((right << 1) | (right >>> 31)); 

    1500. 

  1500. 

    1501. 

  1501. 	    //do this either 1 or 3 times for each chunk of the message

    1502. 

  1502. 	    for (j=0; j<iterations; j+=3) {

    1503. 

  1503. 	      endloop = looping[j+1];

    1504. 

  1504. 	      loopinc = looping[j+2];

    1505. 

  1505. 	      //now go through and perform the encryption or decryption  

    1506. 

  1506. 	      for (i=looping[j]; i!=endloop; i+=loopinc) { //for efficiency

    1507. 

  1507. 	        right1 = right ^ keys[i]; 

    1508. 

  1508. 	        right2 = ((right >>> 4) | (right << 28)) ^ keys[i+1];

    1509. 

  1509. 	        //the result is attained by passing these bytes through the S selection functions

    1510. 

  1510. 	        temp = left;

    1511. 

  1511. 	        left = right;

    1512. 

  1512. 	        right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] | spfunction4[(right1 >>> 16) & 0x3f]

    1513. 

  1513. 	              | spfunction6[(right1 >>>  8) & 0x3f] | spfunction8[right1 & 0x3f]

    1514. 

  1514. 	              | spfunction1[(right2 >>> 24) & 0x3f] | spfunction3[(right2 >>> 16) & 0x3f]

    1515. 

  1515. 	              | spfunction5[(right2 >>>  8) & 0x3f] | spfunction7[right2 & 0x3f]);

    1516. 

  1516. 	      }

    1517. 

  1517. 	      temp = left; left = right; right = temp; //unreverse left and right

    1518. 

  1518. 	    } //for either 1 or 3 iterations

    1519. 

  1519. 

    1520. 

  1520. 	    //move then each one bit to the right

    1521. 

  1521. 	    left = ((left >>> 1) | (left << 31)); 

    1522. 

  1522. 	    right = ((right >>> 1) | (right << 31)); 

    1523. 

  1523. 

    1524. 

  1524. 	    //now perform IP-1, which is IP in the opposite direction

    1525. 

  1525. 	    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);

    1526. 

  1526. 	    temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);

    1527. 

  1527. 	    temp = ((right >>> 2) ^ left) & 0x33333333; left ^= temp; right ^= (temp << 2);

    1528. 

  1528. 	    temp = ((left >>> 16) ^ right) & 0x0000ffff; right ^= temp; left ^= (temp << 16);

    1529. 

  1529. 	    temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);

    1530. 

  1530. 

    1531. 

  1531. 	    //for Cipher Block Chaining mode, xor the message with the previous result

    1532. 

  1532. 	    if (mode == 1) {if (encrypt) {cbcleft = left; cbcright = right;} else {left ^= cbcleft2; right ^= cbcright2;}}

    1533. 

  1533. 	    tempresult += String.fromCharCode ((left>>>24), ((left>>>16) & 0xff), ((left>>>8) & 0xff), (left & 0xff), (right>>>24), ((right>>>16) & 0xff), ((right>>>8) & 0xff), (right & 0xff));

    1534. 

  1534. 

    1535. 

  1535. 	    chunk += 8;

    1536. 

  1536. 	    if (chunk == 512) {result += tempresult; tempresult = ""; chunk = 0;}

    1537. 

  1537. 	  } //for every 8 characters, or 64 bits in the message

    1538. 

  1538. 

    1539. 

  1539. 	  //return the result as an array

    1540. 

  1540. 	  return result + tempresult;

    1541. 

  1541. 	} //end of des

    1542. 

  1542. 

    1543. 

  1543. 	//des_createKeys

    1544. 

  1544. 	//this takes as input a 64 bit key (even though only 56 bits are used)

    1545. 

  1545. 	//as an array of 2 integers, and returns 16 48 bit keys

    1546. 

  1546. 	function des_createKeys (key) {

    1547. 

  1547. 	  //declaring this locally speeds things up a bit

    1548. 

  1548. 	  pc2bytes0  = new Array (0,0x4,0x20000000,0x20000004,0x10000,0x10004,0x20010000,0x20010004,0x200,0x204,0x20000200,0x20000204,0x10200,0x10204,0x20010200,0x20010204);

    1549. 

  1549. 	  pc2bytes1  = new Array (0,0x1,0x100000,0x100001,0x4000000,0x4000001,0x4100000,0x4100001,0x100,0x101,0x100100,0x100101,0x4000100,0x4000101,0x4100100,0x4100101);

    1550. 

  1550. 	  pc2bytes2  = new Array (0,0x8,0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808,0,0x8,0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808);

    1551. 

  1551. 	  pc2bytes3  = new Array (0,0x200000,0x8000000,0x8200000,0x2000,0x202000,0x8002000,0x8202000,0x20000,0x220000,0x8020000,0x8220000,0x22000,0x222000,0x8022000,0x8222000);

    1552. 

  1552. 	  pc2bytes4  = new Array (0,0x40000,0x10,0x40010,0,0x40000,0x10,0x40010,0x1000,0x41000,0x1010,0x41010,0x1000,0x41000,0x1010,0x41010);

    1553. 

  1553. 	  pc2bytes5  = new Array (0,0x400,0x20,0x420,0,0x400,0x20,0x420,0x2000000,0x2000400,0x2000020,0x2000420,0x2000000,0x2000400,0x2000020,0x2000420);

    1554. 

  1554. 	  pc2bytes6  = new Array (0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002,0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002);

    1555. 

  1555. 	  pc2bytes7  = new Array (0,0x10000,0x800,0x10800,0x20000000,0x20010000,0x20000800,0x20010800,0x20000,0x30000,0x20800,0x30800,0x20020000,0x20030000,0x20020800,0x20030800);

    1556. 

  1556. 	  pc2bytes8  = new Array (0,0x40000,0,0x40000,0x2,0x40002,0x2,0x40002,0x2000000,0x2040000,0x2000000,0x2040000,0x2000002,0x2040002,0x2000002,0x2040002);

    1557. 

  1557. 	  pc2bytes9  = new Array (0,0x10000000,0x8,0x10000008,0,0x10000000,0x8,0x10000008,0x400,0x10000400,0x408,0x10000408,0x400,0x10000400,0x408,0x10000408);

    1558. 

  1558. 	  pc2bytes10 = new Array (0,0x20,0,0x20,0x100000,0x100020,0x100000,0x100020,0x2000,0x2020,0x2000,0x2020,0x102000,0x102020,0x102000,0x102020);

    1559. 

  1559. 	  pc2bytes11 = new Array (0,0x1000000,0x200,0x1000200,0x200000,0x1200000,0x200200,0x1200200,0x4000000,0x5000000,0x4000200,0x5000200,0x4200000,0x5200000,0x4200200,0x5200200);

    1560. 

  1560. 	  pc2bytes12 = new Array (0,0x1000,0x8000000,0x8001000,0x80000,0x81000,0x8080000,0x8081000,0x10,0x1010,0x8000010,0x8001010,0x80010,0x81010,0x8080010,0x8081010);

    1561. 

  1561. 	  pc2bytes13 = new Array (0,0x4,0x100,0x104,0,0x4,0x100,0x104,0x1,0x5,0x101,0x105,0x1,0x5,0x101,0x105);

    1562. 

  1562. 

    1563. 

  1563. 	  //how many iterations (1 for des, 3 for triple des)

    1564. 

  1564. 	  var iterations = key.length > 8 ? 3 : 1; //changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys

    1565. 

  1565. 	  //stores the return keys

    1566. 

  1566. 	  var keys = new Array (32 * iterations);

    1567. 

  1567. 	  //now define the left shifts which need to be done

    1568. 

  1568. 	  var shifts = new Array (0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);

    1569. 

  1569. 	  //other variables

    1570. 

  1570. 	  var lefttemp, righttemp, m=0, n=0, temp;

    1571. 

  1571. 

    1572. 

  1572. 	  for (var j=0; j<iterations; j++) { //either 1 or 3 iterations

    1573. 

  1573. 	    left = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);

    1574. 

  1574. 	    right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);

    1575. 

  1575. 

    1576. 

  1576. 	    temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);

    1577. 

  1577. 	    temp = ((right >>> -16) ^ left) & 0x0000ffff; left ^= temp; right ^= (temp << -16);

    1578. 

  1578. 	    temp = ((left >>> 2) ^ right) & 0x33333333; right ^= temp; left ^= (temp << 2);

    1579. 

  1579. 	    temp = ((right >>> -16) ^ left) & 0x0000ffff; left ^= temp; right ^= (temp << -16);

    1580. 

  1580. 	    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);

    1581. 

  1581. 	    temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);

    1582. 

  1582. 	    temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);

    1583. 

  1583. 

    1584. 

  1584. 	    //the right side needs to be shifted and to get the last four bits of the left side

    1585. 

  1585. 	    temp = (left << 8) | ((right >>> 20) & 0x000000f0);

    1586. 

  1586. 	    //left needs to be put upside down

    1587. 

  1587. 	    left = (right << 24) | ((right << 8) & 0xff0000) | ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);

    1588. 

  1588. 	    right = temp;

    1589. 

  1589. 

    1590. 

  1590. 	    //now go through and perform these shifts on the left and right keys

    1591. 

  1591. 	    for (var i=0; i < shifts.length; i++) {

    1592. 

  1592. 	      //shift the keys either one or two bits to the left

    1593. 

  1593. 	      if (shifts[i]) {left = (left << 2) | (left >>> 26); right = (right << 2) | (right >>> 26);}

    1594. 

  1594. 	      else {left = (left << 1) | (left >>> 27); right = (right << 1) | (right >>> 27);}

    1595. 

  1595. 	      left &= -0xf; right &= -0xf;

    1596. 

  1596. 

    1597. 

  1597. 	      //now apply PC-2, in such a way that E is easier when encrypting or decrypting

    1598. 

  1598. 	      //this conversion will look like PC-2 except only the last 6 bits of each byte are used

    1599. 

  1599. 	      //rather than 48 consecutive bits and the order of lines will be according to 

    1600. 

  1600. 	      //how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7

    1601. 

  1601. 	      lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf]

    1602. 

  1602. 	              | pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf]

    1603. 

  1603. 	              | pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf]

    1604. 

  1604. 	              | pc2bytes6[(left >>> 4) & 0xf];

    1605. 

  1605. 	      righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf]

    1606. 

  1606. 	                | pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf]

    1607. 

  1607. 	                | pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf]

    1608. 

  1608. 	                | pc2bytes13[(right >>> 4) & 0xf];

    1609. 

  1609. 	      temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff; 

    1610. 

  1610. 	      keys[n++] = lefttemp ^ temp; keys[n++] = righttemp ^ (temp << 16);

    1611. 

  1611. 	    }

    1612. 

  1612. 	  } //for each iterations

    1613. 

  1613. 	  //return the keys we've created

    1614. 

  1614. 	  return keys;

    1615. 

  1615. 	} //end of des_createKeys

    1616. 

  1616. 

    1617. 

  1617. //Convierte una cadena a Base 64. Debido a un error en el algoritmo original, pasaremos

    1618. 

  1618. // de cadena a hexadecimal y de hexadecimal a Base64

    1619. 

  1619. function stringToBase64 (s) {

    1620. 

  1620. 	return hexToBase64(stringToHex(s));

    1621. 

  1621. }

    1622. 

  1622. 

    1623. 

  1623. //Convert a base64 string into a normal string

    1624. 

  1624. function base64ToString (s) {

    1625. 

  1625.   //the base 64 characters

    1626. 

  1626.   var BASE64 = new Array ('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/');

    1627. 

  1627. 	

    1628. 

  1628.   var decode = new Object();

    1629. 

  1629.   for (var i=0; i<BASE64.length; i++) {decode[BASE64[i]] = i;} //inverse of the array

    1630. 

  1630.   decode['='] = 0; //add the equals sign as well

    1631. 

  1631.   var r = "", c1, c2, c3, c4, len=s.length; //define variables

    1632. 

  1632.   s += "===="; //just to make sure it is padded correctly

    1633. 

  1633.   for (var i=0; i<len; i+=4) { //4 input characters at a time

    1634. 

  1634.     c1 = s.charAt(i); //the 1st base64 input characther

    1635. 

  1635.     c2 = s.charAt(i+1);

    1636. 

  1636.     c3 = s.charAt(i+2);

    1637. 

  1637.     c4 = s.charAt(i+3);

    1638. 

  1638.     r += String.fromCharCode (((decode[c1] << 2) & 0xff) | (decode[c2] >> 4)); //reform the string

    1639. 

  1639.     if (c3 != '=') r += String.fromCharCode (((decode[c2] << 4) & 0xff) | (decode[c3] >> 2));

    1640. 

  1640.     if (c4 != '=') r += String.fromCharCode (((decode[c3] << 6) & 0xff) | decode[c4]);

    1641. 

  1641.   }

    1642. 

  1642.   return r;

    1643. 

  1643. }

    1644. 

  1644. 

    1645. 

  1645. function stringToHex (s) {

    1646. 

  1646. 	  var r = "";

    1647. 

  1647. 	  var hexes = new Array ("0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f");

    1648. 

  1648. 	  for (var i=0; i<s.length; i++) {r += hexes [s.charCodeAt(i) >> 4] + hexes [s.charCodeAt(i) & 0xf];}

    1649. 

  1649. 	  return r;

    1650. 

  1650. }

    1651. 

  1651. 

    1652. 

  1652. // --- Funciones para pasar de Hexadecimal a base64

    1653. 

  1653. 

    1654. 

  1654. var tableStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    1655. 

  1655. var tableStr_URL_SAFE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

    1656. 

  1656. 

    1657. 

  1657. function btoa (bin, urlSafe) {

    1658. 

  1658. 	var table = (urlSafe == true ? tableStr_URL_SAFE : tableStr).split("");

    1659. 

  1659. 	

    1660. 

  1660. 	for (var i = 0, j = 0, len = bin.length / 3, base64 = []; i < len; ++i) {

    1661. 

  1661. 		var a = bin.charCodeAt(j++), b = bin.charCodeAt(j++), c = bin.charCodeAt(j++);

    1662. 

  1662. 		if ((a | b | c) > 255) throw new Error("String contains an invalid character");

    1663. 

  1663. 		base64[base64.length] = table[a >> 2] + table[((a << 4) & 63) | (b >> 4)] +

    1664. 

  1664. 		(isNaN(b) ? "=" : table[((b << 2) & 63) | (c >> 6)]) +

    1665. 

  1665. 		(isNaN(b + c) ? "=" : table[c & 63]);

    1666. 

  1666. 	}

    1667. 

  1667. 	return base64.join("");

    1668. 

  1668. }

    1669. 

  1669. 

    1670. 

  1670. function hexToBase64(str, urlSafe) {

    1671. 

  1671. 	var byteString;

    1672. 

  1672. 	var byteArray = str.replace(/\r|\n/g, "").replace(/([\da-fA-F]{2}) ?/g, "0x$1 ").replace(/ +$/, "").split(" ");

    1673. 

  1673. 	try {

    1674. 

  1674. 		byteString = String.fromCharCode.apply(null, byteArray);

    1675. 

  1675. 	} catch (e) {

    1676. 

  1676. 		var strTemp = "";

    1677. 

  1677. 		for (var i = 0, len = byteArray.length; i < len; i++) {

    1678. 

  1678. 			strTemp += String.fromCharCode(byteArray[i]);

    1679. 

  1679. 		}

    1680. 

  1680. 		byteString = strTemp;

    1681. 

  1681. 	}

    1682. 

  1682. 	

    1683. 

  1683. 	return btoa(byteString, urlSafe);

    1684. 

  1684. }
    1685.