PageSourceSearch

https://sso.dcu.ac.kr/common/raonnx/ksbiz/js/ksbiz_internal.js

js dcu.ac.kr collected 2026-10-08 09:54:35 UTC 46,323 bytes, 1,278 lines download raw bytes

1var ksbizAct = {
2		
3	/////////// sign block ////////////////////////
4	preSign : function(bucket){
5		kslog("ksbizAct.preSign", bucket);
6        if(bucket.options.addNonce){
7            DC_get(KSBizConfig.nonceUrl, "", function(nonce){
8            	if(nonce){
9                    if(nonce.length != 20){
10						alert("전자서명 실패[nonce 오류]:" + nonce.length);
11						bucket.result = {};
12						bucket.result.status = "9999";
13						bucket.result.message = "[ksbizAct.preSign] nonce value is length error";
14						bucket.bizcallback(bucket);
15                        return;
16                    }
17                    if(bucket.data.length > 0) bucket.data += "&";
18                    var nonceKeyName = KSBizConfig.nonceKeyName || "ksbizNonce";
19                    bucket.data += nonceKeyName + "=" + encodeURIComponent(nonce);
20                    ksbizAct.setSignTitleImage(bucket);
21            	} else {
22            		bucket.result = {};
23        			bucket.result.status = "9999";
24            		bucket.result.message = "[ksbizAct.preSign] nonce value is not exist";
25        			bucket.bizcallback(bucket);
26            	}
27            });
28        } else {
29        	ksbizAct.setSignTitleImage(bucket);
30        }
31	},
32	
33	setSignTitleImage : function(bucket){
34		kslog("ksbizAct.setSignTitleImage", bucket);
35        if(bucket.options.confirmSignTitleImageUrl){
36            DC_get(bucket.options.confirmSignTitleImageUrl, "", function(img){
37            	if(img){
38            		bucket.options.confirmSignTitleImage = img;
39            		ksbizAct.sign(bucket);
40            	} else {
41            		bucket.result = {};
42            		bucket.result.result = "9999";
43            		bucket.result.message = "[ksbizAct.setSignTitleImage] signTitleImage is not exist";
44        			bucket.bizcallback(bucket);
45            	}
46            });
47        } else {
48        	ksbizAct.sign(bucket);
49        }
50	},
51
52	sign : function(bucket){
53		kslog("ksbizAct.sign", bucket);
54		var resSignCallback = function(data, error){
55			if(error){
56				bucket.result = {};
57				bucket.result.status = error.status;
58				bucket.result.message = error.message; 
59				bucket.bizcallback(bucket);				
60			} else {
61				if(data.signedData){
62					bucket.result = {};
63					bucket.result.status = 1;
64					bucket.result.data = data.signedData;
65					if(data.vidRandom) bucket.result.vidRandom = data.vidRandom;
66					if(data.signAlgorithm) bucket.result.signAlgorithm = data.signAlgorithm;
67					if(data.signer) bucket.result.signer = TOUCHENEX_UTIL.Base64.decode(data.signer);
68					if(data.rawData) bucket.result.rawData = TOUCHENEX_UTIL.Base64.decode(data.rawData);
69					if(data.fileName) bucket.result.fileName = TOUCHENEX_UTIL.Base64.decode(data.fileName);
70					bucket.bizcallback(bucket);
71				} else {
72					bucket.result = {};
73					bucket.result.status = 0;
74					bucket.result.data = "";
75					bucket.result.vidRandom = "";
76					bucket.bizcallback(bucket);			
77				}
78			}
79		};
80		
81		nativeBrowserCheck();
82		if(KSBizConfig.uitype == "native"){
83			if(KeySharpBiz.chkInit(arguments)){
84				// set logoImage
85		        ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
86		        	if(result){
87				        if(bucket.options.subjectCertFilter || bucket.options.resetCertificate){
88				        	ksbizExtInterface.resetCertificate();
89				        }
90				        
91						ksbizExtInterface.sign(bucket.data, bucket.options, resSignCallback);
92		        	} else {
93		        		bucket.result = {};
94		    			bucket.result.status = "9999";
95		    			bucket.result.message = "[ksbizAct.setLogoImage] logoImage setting fail";
96		    			bucket.bizcallback(bucket);
97		        	}
98		        });
99			}
100		} else {
101			if(bucket.options.subjectCertFilter || bucket.options.resetCertificate){
102	        	bucket.options.resetCertificate = true;
103			}
104			var data = {};
105			data.policyID = "DigitalSign";
106			data.sourceEncoding = bucket.options.encoding?bucket.options.encoding:"utf-8";
107			data.plainText = bucket.data;
108			data.options = bucket.options;
109			
110			XWC.cxsign(data, resSignCallback);
111		}
112	},
113
114	/////////// channelEncrypt block ////////////////////////
115	channelInit : function(bucket) {
116		kslog("ksbizAct.channelInit", bucket);
117		// 1. clientR 생성
118		ksbizExtInterface.channel2Init({}, function(clientR, error){
119			if(error){
120				bucket.result = {};
121				bucket.result.status = error.status;
122				bucket.result.message = "[ksbizAct.channelInit] channel2Init Fail : " + error.message;
123				bucket.bizcallback(bucket);
124			} else {
125				if(clientR && clientR.random){
126					kslog("ksbizAct.channelInit.clientR", clientR);
127					var cRandom = clientR.random;
128					var cStatus = clientR.status;
129					
130					// 2. 서버에게 clientR 전송
131					var keyValue = "msg=" + encodeURIComponent(cRandom);
132					DC_get(KSBizConfig.channelSvrUrl, keyValue, function(serverCRKE){
133						kslog("ksbizAct.channelInit.serverCRKE", serverCRKE);
134						if(serverCRKE){
135							if(!serverCRKE.startsWith("-")){
136								bucket.serverCRKE = serverCRKE;
137								// 클라이언트가 3인 경우 발급한 랜덤값으로 reset
138								//if(cStatus == "3") {
139									//bucket.options.reset = true;
140								//}
141								// 3. 서버로부터 전달받은 serverCRKE를 다음단계로 패스
142								ksbizAct._sendClientFinished(bucket);
143							} else {
144								// 서버에 키교환이 완료 된 상태일때
145								if(serverCRKE == "-10702"){
146									// 서버와 클라이언트가 이미 키교환을 했으므로 성공 처리
147									if(cStatus == "3") {
148										kslog("ksbizAct.channelInit", "Already Key Exchange... success return..");
149										ksbizAct._symEnCrypt(bucket); // block encrypt..
150									} else {
151										// 서버세션 리셋후 재발급
152										var resetParam = keyValue += "&option=reset";
153										DC_get(KSBizConfig.channelSvrUrl, keyValue, function(resetServerCRKE){
154											kslog("ksbizAct.channelInit.resetServerCRKE", resetServerCRKE);
155											if(resetServerCRKE){
156												if(!resetServerCRKE.startsWith("-")){
157													// reSession을 통한 경우 reset 값을 셋..
158													bucket.serverCRKE = resetServerCRKE;
159													bucket.options.reset = true;
160													ksbizAct._sendClientFinished(bucket);
161												} else {
162													bucket.result = {};
163													bucket.result.status = resetServerCRKE;
164													bucket.result.message = "[ksbizAct.channelInit] DC_get reSession Fail";
165													bucket.bizcallback(bucket);
166												}
167											} else {
168												bucket.result = {};
169												bucket.result.status = "9999";
170												bucket.result.message = "[ksbizAct.channelInit] DC_get reSession Fail response not exist";
171												bucket.bizcallback(bucket);
172											}
173										});
174									}
175								} else if (serverCRKE == "-10703"){
176									// 서버세션 리셋후 재발급
177									var resetParam = keyValue += "&option=reset";
178									DC_get(KSBizConfig.channelSvrUrl, keyValue, function(resetServerCRKE){
179										kslog("ksbizAct.channelInit.resetServerCRKE", resetServerCRKE);
180										if(resetServerCRKE){
181											if(!resetServerCRKE.startsWith("-")){
182												// reSession을 통한 경우 reset 값을 셋..
183												bucket.serverCRKE = resetServerCRKE;
184												bucket.options.reset = true;
185												ksbizAct._sendClientFinished(bucket);
186											} else {
187												bucket.result = {};
188												bucket.result.status = resetServerCRKE;
189												bucket.result.message = "[ksbizAct.channelInit] DC_get reSession Fail";
190												bucket.bizcallback(bucket);
191											}
192										} else {
193											bucket.result = {};
194											bucket.result.status = "9999";
195											bucket.result.message = "[ksbizAct.channelInit] DC_get reSession Fail response not exist";
196											bucket.bizcallback(bucket);
197										}
198									});
199								} else {
200									var errMsg = "";
201									if(serverCRKE == "-10701"){
202										errMsg = "url parameter invalid";
203									} else {
204										errMsg = "server error";
205									}
206									bucket.result = {};
207									bucket.result.status = serverCRKE;
208									bucket.result.message = "[ksbizAct.channelInit] DC_get serverCRKE Fail : " + errMsg;
209									bucket.bizcallback(bucket);
210								}
211							}
212						} else {
213							bucket.result = {};
214							bucket.result.status = "9999";
215							bucket.result.message = "[ksbizAct.channelInit] DC_get Fail response not exist";
216							bucket.bizcallback(bucket);
217						}
218					});
219				} else {
220					bucket.result = {};
221					bucket.result.status = "9999";
222					bucket.result.message = "[ksbizAct.channelInit] channel2Init Fail clientR not exist";
223					bucket.bizcallback(bucket);
224				}
225			}
226		});
227	},
228	
229	_sendClientFinished : function(bucket) {
230		kslog("ksbizAct._sendClientFinished", bucket);
231		// 1. serverCRKE 검증 & clientKEF 생성
232		ksbizExtInterface.channel2Verify(bucket.serverCRKE, bucket.options, function(clientKEF, error){ //..callback1
233			if(error){
234				bucket.result = {};
235				bucket.result.status = error.status;
236				bucket.result.message = "[ksbizAct._sendClientFinished] channel2Verify Fail : " + error.message; 
237				bucket.bizcallback(bucket);
238			} else {
239				if(clientKEF){
240					kslog("ksbizAct._sendClientFinished.clientKEF", clientKEF);
241					// 2. 서버에게 clientKEF 전송
242					var keyValue = "msg=" + encodeURIComponent(clientKEF);
243					DC_get(KSBizConfig.channelSvrUrl, keyValue, function(serverF){ //..callback2
244						kslog("ksbizAct._sendClientFinished.serverF", serverF);
245						if(serverF){
246							if(!serverF.startsWith("-")){
247								bucket.serverF = serverF;
248								// 3. 서버로부터 전달받은 serverF를 다음단계로 패스
249								ksbizAct._verifyServerFinished(bucket); //..callback3
250							} else {
251								var errMsg = "";
252								if(serverF == "-10701"){
253									errMsg = "url parameter invalid";
254								} else {
255									errMsg = "server error";
256								}
257								bucket.result = {};
258								bucket.result.status = serverF;
259								bucket.result.message = "[ksbizAct._sendClientFinished] DC_get serverF Fail";
260								bucket.bizcallback(bucket);
261							}
262						} else {
263							bucket.result = {};
264							bucket.result.status = "9999";
265							bucket.result.message = "[ksbizAct._sendClientFinished] DC_get Fail response not exist";
266							bucket.bizcallback(bucket);
267						}
268					});
269				} else {
270					bucket.result = {};
271					bucket.result.status = "9999";
272					bucket.result.message = "[ksbizAct._sendClientFinished] channel2Verify Fail clientKEF not exist";
273					bucket.bizcallback(bucket);
274				}
275			}
276		});
277	},
278	
279	_verifyServerFinished : function(bucket) {
280		kslog("ksbizAct._verifyServerFinished", bucket);		
281		// 1. serverF 검증
282		ksbizExtInterface.channel2Final(bucket.serverF, bucket.options, function(isSuccess, error){
283			if(error){
284				bucket.result = {};
285				bucket.result.status = error.status;
286				bucket.result.message = "[ksbizAct._verifyServerFinished] channel2Final Fail : " + error.message; 
287				bucket.bizcallback(bucket);
288			} else {
289				if(isSuccess){
290					kslog("ksbizAct._verifyServerFinished.isSuccess", isSuccess);
291					ksbizAct._symEnCrypt(bucket); // block encrypt..
292					// bucket.result = {};
293					// bucket.result.status = "1";
294					// bucket.bizcallback(bucket);
295				} else {
296					bucket.result = {};
297					bucket.result.status = "9999";
298					bucket.result.message = "[ksbizAct._verifyServerFinished] channel2Final Fail isSuccess not exist";
299					bucket.bizcallback(bucket);
300				}
301			}
302		});
303	},
304	
305	_symEnCrypt : function(bucket){
306		kslog("ksbizAct._symEnCrypt", bucket);
307		ksbizExtInterface.channel2Encrypt(bucket.data, bucket.options, function(encStr, error){
308			if(error){
309				bucket.result = {};
310				bucket.result.status = error.status;
311				bucket.result.message = "[ksbizAct._symEnCrypt] channel2Encrypt Fail : " + error.message; 
312				bucket.bizcallback(bucket);
313			} else {
314				if(encStr){
315					kslog("ksbizAct._symEnCrypt.encStr", encStr);
316					bucket.result = {};
317					bucket.result.status = "1";
318					bucket.result.data = encStr;
319					bucket.bizcallback(bucket);
320				} else {
321					bucket.result = {};
322					bucket.result.status = "9999";
323					bucket.result.message = "[ksbizAct._symEnCrypt] channel2Encrypt Fail encStr not exist";
324					bucket.bizcallback(bucket);
325				}
326			}
327		});
328	},
329	
330	_symDeCrypt : function(bucket){
331		kslog("ksbizAct._symDeCrypt", bucket);
332		ksbizExtInterface.channel2Decrypt(bucket.data, bucket.options, function(decStr, error){
333			if(error){
334				bucket.result = {};
335				bucket.result.status = error.status;
336				bucket.result.message = "[ksbizAct._symDeCrypt] channel2Decrypt Fail : " + error.message; 
337				bucket.bizcallback(bucket);
338			} else {
339				if(decStr){
340					kslog("ksbizAct._symDeCrypt.decStr", decStr);
341					bucket.result = {};
342					bucket.result.status = "1";
343					bucket.result.data = decStr;
344					bucket.bizcallback(bucket);
345				} else {
346					bucket.result = {};
347					bucket.result.status = "9999";
348					bucket.result.message = "[ksbizAct._symDeCrypt] channel2Decrypt Fail decStr not exist";
349					bucket.bizcallback(bucket);
350				}
351			}
352		});
353	},
354
355	/////////// signFile block ////////////////////////
356	signFile : function(bucket){
357		ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
358        	if(result){
359				ksbizExtInterface.signFile(bucket.srcfile, bucket.destfile, bucket.options, function(data, error){
360					if(error){
361						bucket.result = {};
362						bucket.result.status = error.status;
363						bucket.result.message = "[ksbizAct.signFile] signFile Fail [" + error.status + "] " + error.message; 
364						bucket.bizcallback(bucket);
365					} else {
366						if(data.fileName){
367							bucket.result = {};
368							bucket.result.status = 1;
369							bucket.result.fileName = data.fileName;
370							bucket.bizcallback(bucket);
371						} else {
372							bucket.result = {};
373							bucket.result.status = 0;
374							bucket.result.fileName = "";
375							bucket.bizcallback(bucket);
376						}
377					}
378				});
379        	} else {
380        		bucket.result = {};
381    			bucket.result.status = "9999";
382    			bucket.result.message = "[ksbizAct.setLogoImage] logoImage setting fail";
383    			bucket.bizcallback(bucket);
384        	}
385        });
386	},
387    
388	addSignFile : function(bucket){
389		ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
390        	if(result){
391				ksbizExtInterface.addSignFile(bucket.srcfile, bucket.destfile, bucket.options, function(data, error){
392					if(error){
393						bucket.result = {};
394						bucket.result.status = error.status;
395						bucket.result.message = "[ksbizAct.addSignFile] addSignFile Fail [" + error.status + "] " + error.message; 
396						bucket.bizcallback(bucket);
397					} else {
398						if(data.fileName){
399							bucket.result = {};
400							bucket.result.status = 1;
401							bucket.result.fileName = data.fileName;
402							bucket.bizcallback(bucket);
403						} else {
404							bucket.result = {};
405							bucket.result.status = 0;
406							bucket.result.fileName = "";
407							bucket.bizcallback(bucket);
408						}
409					}
410				});
411        	} else {
412        		bucket.result = {};
413    			bucket.result.status = "9999";
414    			bucket.result.message = "[ksbizAct.setLogoImage] logoImage setting fail";
415    			bucket.bizcallback(bucket);
416        	}
417        });
418	},
419	
420	channelEncryptFile : function(bucket){
421        ksbizAct.setServerCert(function(setServerCertResult){
422        	if(setServerCertResult){
423            	if(setServerCertResult.status == 1){
424            		
425            		ksbizAct.setCACert(function(setCACertResult){
426                    	if(setCACertResult){
427                        	if(setServerCertResult.status == 1){
428                        		ksbizAct.encryptFile(bucket);
429                        	} else {
430                        		bucket.result = setCACertResult;
431                        		bucket.bizcallback(bucket);
432                        	}
433                    	} else {
434                    		bucket.result = {};
435                			bucket.result.status = "9999";
436                			bucket.result.message = "[ksbizAct.channelEncryptFile] setCACert Fail";
437                			bucket.bizcallback(bucket);
438                    	}
439            		});
440            	} else {
441            		bucket.result = setServerCertResult;
442            		bucket.bizcallback(bucket);
443            	}
444        	} else {
445        		bucket.result = {};
446    			bucket.result.status = "9999";
447    			bucket.result.message = "[ksbizAct.channelEncryptFile] setServerCert Fail";
448    			bucket.bizcallback(bucket);
449        	}
450        });
451	},
452	
453	encryptFile : function(bucket){
454        if(!bucket.srcfile) bucket.srcfile = "";
455        if(!bucket.destfile) bucket.destfile = "";
456        if(!bucket.options)	bucket.options = {};
457        if(!bucket.options.cipherAlgorithm) bucket.options.cipherAlgorithm = KSBizConfig.cipherAlgorithm;
458        if(!bucket.options.saveType) bucket.options.saveType = KSBizConfig.saveType;
459        if(!bucket.options.cmsKeyEncryptionAlgorithm && KSBizConfig.cmsKeyEncryptionAlgorithm)
460        	bucket.options.cmsKeyEncryptionAlgorithm = KSBizConfig.cmsKeyEncryptionAlgorithm;
461        
462        ksbizExtInterface.encryptFile(bucket.srcfile, bucket.destfile, bucket.options, function(data, error){
463			if(error){
464				bucket.result = {};
465				bucket.result.status = error.status;
466				bucket.result.message = "[ksbizAct.encryptFile] encryptFile Fail [" + error.status + "] " + error.message; 
467				bucket.bizcallback(bucket);
468			} else {
469				if(data.fileName){
470					bucket.result = {};
471					bucket.result.status = 1;
472					bucket.result.fileName = data.fileName;
473					bucket.bizcallback(bucket);
474				} else {
475					bucket.result = {};
476					bucket.result.status = 9999;
477					bucket.result.message = "[ksbizAct.encryptFile] encryptFile Fail";
478					bucket.bizcallback(bucket);
479				}
480			}
481        });
482	},
483	
484	decryptFile : function(bucket){
485        if(!bucket.srcfile) bucket.srcfile = "";
486        if(!bucket.destfile) bucket.destfile = "";
487        if(!bucket.options)	bucket.options = {};
488        if(!bucket.options.cipherAlgorithm) bucket.options.cipherAlgorithm = KSBizConfig.cipherAlgorithm;
489        if(!bucket.options.saveType) bucket.options.saveType = KSBizConfig.saveType;
490        
491        ksbizExtInterface.decryptFile(bucket.srcfile, bucket.destfile, bucket.options, function(data, error){
492			if(error){
493				bucket.result = {};
494				bucket.result.status = error.status;
495				bucket.result.message = "[ksbizAct.decryptFile] decryptFile Fail [" + error.status + "] " + error.message; 
496				bucket.bizcallback(bucket);
497			} else {
498				if(data.fileName){
499					bucket.result = {};
500					bucket.result.status = 1;
501					bucket.result.fileName = data.fileName;
502					bucket.bizcallback(bucket);
503				} else {
504					bucket.result = {};
505					bucket.result.status = 9999;
506					bucket.result.message = "[ksbizAct.decryptFile] decryptFile Fail";
507					bucket.bizcallback(bucket);
508				}
509			}
510        });
511	},
512	
513	compressFile : function(bucket){
514        if(!bucket.options)	bucket.options = {};
515        ksbizExtInterface.compressFile(bucket.srcfile, bucket.destfile, bucket.options, function(data, error){
516			if(error){
517				bucket.result = {};
518				bucket.result.status = error.status;
519				bucket.result.message = "[ksbizAct.compressFile] compressFile Fail [" + error.status + "] " + error.message; 
520				bucket.bizcallback(bucket);
521			} else {
522				if(data.fileName){
523					bucket.result = {};
524					bucket.result.status = 1;
525					bucket.result.fileName = data.fileName;
526					bucket.bizcallback(bucket);
527				} else {
528					bucket.result = {};
529					bucket.result.status = 9999;
530					bucket.result.message = "[ksbizAct.compressFile] compressFile Fail";
531					bucket.bizcallback(bucket);
532				}
533			}
534        });
535	},
536	
537	uncompressFile : function(bucket){
538        if(!bucket.options)	bucket.options = {};
539        ksbizExtInterface.uncompressFile(bucket.srcfile, bucket.destfile, bucket.options, function(data, error){
540			if(error){
541				bucket.result = {};
542				bucket.result.status = error.status;
543				bucket.result.message = "[ksbizAct.uncompressFile] uncompressFile Fail [" + error.status + "] " + error.message; 
544				bucket.bizcallback(bucket);
545			} else {
546				if(data.fileName){
547					bucket.result = {};
548					bucket.result.status = 1;
549					bucket.result.fileName = data.fileName;
550					bucket.bizcallback(bucket);
551				} else {
552					bucket.result = {};
553					bucket.result.status = 9999;
554					bucket.result.message = "[ksbizAct.uncompressFile] uncompressFile Fail";
555					bucket.bizcallback(bucket);
556				}
557			}
558        });
559	},
560	
561	signFileUrl : function(bucket){
562		ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
563        	if(result){
564				ksbizExtInterface.signFileUrl(bucket.url, bucket.options, function(data, error){
565					if(error){
566						bucket.result = {};
567						bucket.result.status = error.status;
568						bucket.result.message = "[ksbizAct.signFileUrl] signFileUrl Fail [" + error.status + "] " + error.message; 
569						bucket.bizcallback(bucket);
570					} else {
571						if(data.fileName){
572							bucket.result = {};
573							bucket.result.status = 1;
574							bucket.result.fileName = data.fileName;
575							bucket.bizcallback(bucket);
576						} else {
577							bucket.result = {};
578							bucket.result.status = 0;
579							bucket.result.fileName = "";
580							bucket.bizcallback(bucket);
581						}
582					}
583				});
584        	} else {
585        		bucket.result = {};
586    			bucket.result.status = "9999";
587    			bucket.result.message = "[ksbizAct.setLogoImage] logoImage setting fail";
588    			bucket.bizcallback(bucket);
589        	}
590        });
591	},
592	
593	channelEncryptFileUrl : function(bucket){
594		ksbizAct.setServerCert(function(setServerCertResult){
595        	if(setServerCertResult){
596            	if(setServerCertResult.status == 1){
597            		ksbizAct.setCACert(function(setCACertResult){
598                    	if(setCACertResult){
599                        	if(setServerCertResult.status == 1){
600                        		ksbizAct.encryptFileUrl(bucket);
601                        	} else {
602                        		bucket.result = setCACertResult;
603                        		bucket.bizcallback(bucket);
604                        	}
605                    	} else {
606                    		bucket.result = {};
607                			bucket.result.status = "9999";
608                			bucket.result.message = "[ksbizAct.channelEncryptFileUrl] setCACert Fail";
609                			bucket.bizcallback(bucket);
610                    	}
611            		});
612            		
613            	} else {
614            		bucket.result = setServerCertResult;
615            		bucket.bizcallback(bucket);
616            	}
617        	} else {
618        		bucket.result = {};
619    			bucket.result.status = "9999";
620    			bucket.result.message = "[ksbizAct.channelEncryptFileUrl] setServerCert Fail";
621    			bucket.bizcallback(bucket);
622        	}
623        });
624	},
625	
626	encryptFileUrl : function(bucket){
627		ksbizExtInterface.encryptFileUrl(bucket.url, bucket.options, function(data, error){
628			if(error){
629				bucket.result = {};
630				bucket.result.status = error.status;
631				bucket.result.message = "[ksbizAct.encryptFileUrl] encryptFileUrl Fail [" + error.status + "] " + error.message; 
632				bucket.bizcallback(bucket);
633			} else {
634				if(data.fileName){
635					bucket.result = {};
636					bucket.result.status = 1;
637					bucket.result.fileName = data.fileName;
638					bucket.bizcallback(bucket);
639				} else {
640					bucket.result = {};
641					bucket.result.status = 0;
642					bucket.result.fileName = "";
643					bucket.bizcallback(bucket);
644				}
645			}
646		});
647	},
648	
649	signAndChannelEncryptFileUrl : function(bucket){
650		ksbizAct.setServerCert(function(setServerCertResult){
651        	if(setServerCertResult){
652            	if(setServerCertResult.status == 1){
653            		
654            		ksbizAct.setCACert(function(setCACertResult){
655                    	if(setCACertResult){
656                        	if(setServerCertResult.status == 1){
657                        		
658                        		ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
659                                	if(result){
660                                		
661                        				ksbizExtInterface.signAndChannelEncryptFileUrl(bucket.url, bucket.options, function(data, error){
662                        					if(error){
663                        						bucket.result = {};
664                        						bucket.result.status = error.status;
665                        						bucket.result.message = "[ksbizAct.signAndChannelEncryptFileUrl] signAndChannelEncryptFileUrl Fail [" + error.status + "] " + error.message; 
666                        						bucket.bizcallback(bucket);
667                        					} else {
668                        						if(data.fileName){
669                        							bucket.result = {};
670                        							bucket.result.status = 1;
671                        							bucket.result.fileName = data.fileName;
672                        							bucket.bizcallback(bucket);
673                        						} else {
674                        							bucket.result = {};
675                        							bucket.result.status = 0;
676                        							bucket.result.fileName = "";
677                        							bucket.bizcallback(bucket);
678                        						}
679                        					}
680                        				});
681                                	} else {
682                                		bucket.result = {};
683                            			bucket.result.status = "9999";
684                            			bucket.result.message = "[ksbizAct.signAndChannelEncryptFileUrl] logoImage setting fail";
685                            			bucket.bizcallback(bucket);
686                                	}
687                                });
688                        	} else {
689                        		bucket.result = setCACertResult;
690                        		bucket.bizcallback(bucket);
691                        	}
692                    	} else {
693                    		bucket.result = {};
694                			bucket.result.status = "9999";
695                			bucket.result.message = "[ksbizAct.signAndChannelEncryptFileUrl] setCACert Fail";
696                			bucket.bizcallback(bucket);
697                    	}
698            		});
699            	} else {
700            		bucket.result = setServerCertResult;
701            		bucket.bizcallback(bucket);
702            	}
703        	} else {
704        		bucket.result = {};
705    			bucket.result.status = "9999";
706    			bucket.result.message = "[ksbizAct.signAndChannelEncryptFileUrl] setServerCert Fail";
707    			bucket.bizcallback(bucket);
708        	}
709        });
710	},
711	
712	addSignFileUrl : function(bucket){
713		ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
714        	if(result){
715				ksbizExtInterface.addSignFileUrl(bucket.downloadUrl, bucket.uploadUrl, bucket.options, function(data, error){
716					if(error){
717						bucket.result = {};
718						bucket.result.status = error.status;
719						bucket.result.message = "[ksbizAct.addSignFileUrl] addSignFileUrl Fail [" + error.status + "] " + error.message; 
720						bucket.bizcallback(bucket);
721					} else {
722						if(data.fileName){
723							bucket.result = {};
724							bucket.result.status = 1;
725							bucket.result.fileName = data.fileName;
726							bucket.bizcallback(bucket);
727						} else {
728							bucket.result = {};
729							bucket.result.status = 0;
730							bucket.result.fileName = "";
731							bucket.bizcallback(bucket);
732						}
733					}
734				});
735        	} else {
736        		bucket.result = {};
737    			bucket.result.status = "9999";
738    			bucket.result.message = "[ksbizAct.addSignFileUrl] logoImage setting fail";
739    			bucket.bizcallback(bucket);
740        	}
741        });
742	},
743	
744	channelDecryptFileUrl : function(bucket){
745		
746		ksbizAct.setServerCert(function(setServerCertResult){
747        	if(setServerCertResult){
748            	if(setServerCertResult.status == 1){
749            		
750            		ksbizAct.setCACert(function(setCACertResult){
751                    	if(setCACertResult){
752                        	if(setServerCertResult.status == 1){
753                        		
754                        		ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
755                                	if(result){
756                                		
757                                		// SID 가져오기~~~~~
758//                                        var sid = this._getSid();
759//                                        if(sid.length!=20){
760//                                            alert("복호화에 실패했습니다.[sid 오류]");
761//                                            return;
762//                                        }
763                                		var sid = "AAAAAA";
764                                		
765                        				ksbizExtInterface.channelDecryptFileUrl(bucket.url, sid, bucket.data, bucket.options, function(data, error){
766                        					if(error){
767                        						bucket.result = {};
768                        						bucket.result.status = error.status;
769                        						bucket.result.message = "[ksbizAct.channelDecryptFileUrl] channelDecryptFileUrl Fail [" + error.status + "] " + error.message; 
770                        						bucket.bizcallback(bucket);
771                        					} else {
772                        						if(data.fileName){
773                        							bucket.result = {};
774                        							bucket.result.status = 1;
775                        							bucket.result.fileName = data.fileName;
776                        							bucket.bizcallback(bucket);
777                        						} else {
778                        							bucket.result = {};
779                        							bucket.result.status = 0;
780                        							bucket.result.fileName = "";
781                        							bucket.bizcallback(bucket);
782                        						}
783                        					}
784                        				});
785                                	} else {
786                                		bucket.result = {};
787                            			bucket.result.status = "9999";
788                            			bucket.result.message = "[ksbizAct.channelDecryptFileUrl] logoImage setting fail";
789                            			bucket.bizcallback(bucket);
790                                	}
791                                });
792                        	} else {
793                        		bucket.result = setCACertResult;
794                        		bucket.bizcallback(bucket);
795                        	}
796                    	} else {
797                    		bucket.result = {};
798                			bucket.result.status = "9999";
799                			bucket.result.message = "[ksbizAct.channelDecryptFileUrl] setCACert Fail";
800                			bucket.bizcallback(bucket);
801                    	}
802            		});
803            	} else {
804            		bucket.result = setServerCertResult;
805            		bucket.bizcallback(bucket);
806            	}
807        	} else {
808        		bucket.result = {};
809    			bucket.result.status = "9999";
810    			bucket.result.message = "[ksbizAct.channelDecryptFileUrl] setServerCert Fail";
811    			bucket.bizcallback(bucket);
812        	}
813        });
814	},
815	
816	decryptFileUrl : function(bucket){
817		ksbizExtInterface.decryptFileUrl(bucket.url, bucket.options, function(data, error){
818			if(error){
819				bucket.result = {};
820				bucket.result.status = error.status;
821				bucket.result.message = "[ksbizAct.decryptFileUrl] decryptFileUrl Fail [" + error.status + "] " + error.message; 
822				bucket.bizcallback(bucket);
823			} else {
824				if(data.fileName){
825					bucket.result = {};
826					bucket.result.status = 1;
827					bucket.result.fileName = data.fileName;
828					bucket.bizcallback(bucket);
829				} else {
830					bucket.result = {};
831					bucket.result.status = 0;
832					bucket.result.fileName = "";
833					bucket.bizcallback(bucket);
834				}
835			}
836		});
837	},
838	
839	requestCertificate : function(bucket){
840		var requestCertificateCallback = function(data, error){
841			if(error){
842				bucket.result = {};
843				bucket.result.status = error.status;
844				bucket.result.message = "[ksbizAct.requestCertificate] requestCertificate Fail :: " + error.message;
845				if(error.status == "005E" || error.status == "005F"){
846					bucket.result.status = "0";
847					bucket.result.message = "user cancel";
848				}
849				bucket.bizcallback(bucket);
850			} else {
851				if(data){
852					bucket.result = {};
853					bucket.result.status = 1;
854					bucket.result.message = data;
855					bucket.bizcallback(bucket);
856				} else {
857					bucket.result = {};
858					bucket.result.status = 0;
859					bucket.result.message = "user cancel";
860					bucket.bizcallback(bucket);
861				}
862			}
863		};
864
865		nativeBrowserCheck();
866		if(KSBizConfig.uitype == "native"){
867			if(KeySharpBiz.chkInit(arguments)){
868				ksbizExtInterface.requestCertificate(bucket.ca, bucket.host, bucket.port, bucket.referenceValue, bucket.secretValue, bucket.options, requestCertificateCallback);
869			}
870		} else {
871			var data = {};
872			data.policyID = "IssueCert";
873			data.plainText = bucket;
874			data.options = bucket.options;
875			XWC.cxsign(data, requestCertificateCallback);
876		}
877	},
878	
879	updateCertificate : function(bucket){
880		var updateCertificateCallback = function(data, error){
881			if(error){
882				bucket.result = {};
883				bucket.result.status = error.status;
884				bucket.result.message = "[ksbizAct.updateCertificate] updateCertificate Fail :: " + error.message;
885				bucket.bizcallback(bucket);
886			} else {
887				if(data){
888					bucket.result = {};
889					bucket.result.status = 1;
890					bucket.result.message = data;
891					bucket.bizcallback(bucket);
892				} else {
893					bucket.result = {};
894					bucket.result.status = 0;
895					bucket.result.message = "user cancel";
896					bucket.bizcallback(bucket);
897				}
898			}
899		};
900
901		nativeBrowserCheck();
902		if(KSBizConfig.uitype == "native"){
903			if(KeySharpBiz.chkInit(arguments)){
904				ksbizAct.loadLogoImage(KSBizConfig.logoImageUrl, function(result){
905					if(result){
906						ksbizExtInterface.updateCertificate(bucket.ca, bucket.host, bucket.port, bucket.options, updateCertificateCallback);
907					} else {
908						bucket.result = {};
909						bucket.result.status = "9999";
910						bucket.result.message = "[ksbizAct.updateCertificate] logoImage setting fail";
911						bucket.bizcallback(bucket);
912					}
913				});
914			}
915		} else {
916			var data = {};
917			data.policyID = "UpdateCert";
918			data.plainText = bucket;
919			data.options = bucket.options;
920			XWC.cxsign(data, updateCertificateCallback);
921		}
922	},
923	
924	deleteCertificate : function(bucket){
925		ksbizExtInterface.deleteCertificate(bucket.subjectDN, bucket.options, function(data, error){
926			if(error){
927				bucket.result = {};
928				bucket.result.status = error.status;
929				bucket.result.message = "[ksbizAct.deleteCertificate] deleteCertificate Fail :: " + error.message;
930				bucket.bizcallback(bucket);
931			} else {
932				if(data){
933					bucket.result = {};
934					bucket.result.status = 1;
935					bucket.result.message = data;
936					bucket.bizcallback(bucket);
937				} else {
938					bucket.result = {};
939					bucket.result.status = 0;
940					bucket.result.message = "";
941					bucket.bizcallback(bucket);
942				}
943			}
944		});
945	},
946	
947	// browserExport
948	browserExportCert : function(bucket){
949		kslog("ksbizAct.browserExportCert", bucket);
950		var resExportCallback = function(data, error){
951			if(error){
952				bucket.result = {};
953				bucket.result.status = error.status;
954				bucket.result.message = error.message; 
955				bucket.bizcallback(bucket);				
956			} else {
957				bucket.result = {};
958				bucket.result.status = 0;
959				bucket.result.data = "";
960				bucket.result.vidRandom = "";
961				bucket.bizcallback(bucket);			
962			}
963		};
964		
965		if(bucket.options.subjectCertFilter || bucket.options.resetCertificate){
966			bucket.options.resetCertificate = true;
967		}
968		var data = {};
969		data.policyID = "ExportCert";
970		data.sourceEncoding = bucket.options.encoding?bucket.options.encoding:"utf-8";
971		data.options = bucket.options;
972		
973		XWC.cxsign(data, resExportCallback);
974
975	},
976
977	// browserImport
978	browserImportCert : function(bucket){
979		kslog("ksbizAct.browserImportCert", bucket);
980		var resImportallback = function(data, error){
981			if(error){
982				bucket.result = {};
983				bucket.result.status = error.status;
984				bucket.result.message = error.message; 
985				bucket.bizcallback(bucket);				
986			} else {
987				bucket.result = {};
988				bucket.result.status = 0;
989				bucket.result.data = "";
990				bucket.result.vidRandom = "";
991				bucket.bizcallback(bucket);			
992			}
993		};
994		
995		if(bucket.options.subjectCertFilter || bucket.options.resetCertificate){
996			bucket.options.resetCertificate = true;
997		}
998		var data = {};
999		data.policyID = "ImportCert";
1000		data.sourceEncoding = bucket.options.encoding?bucket.options.encoding:"utf-8";
1001		data.options = bucket.options;
1002		
1003		XWC.cxsign(data, resImportallback);
1004
1005	},
1006	
1007    loadLogoImage : function(url, callback){
1008    	kslog("ksbizAct.loadLogoImage.url", url);
1009    	if(KSBizConfig.logoImage){
1010    		ksbizExtInterface.setProperty("logoImage", KSBizConfig.logoImage, callback);
1011    	} else {
1012			if(url){
1013				DC_get(url, "", function(result){
1014					if(result){
1015						//kslog("ksbizAct.loadLogoImage.result", result);
1016						kslog("ksbizAct.loadLogoImage.result", "success");
1017						KSBizConfig.logoImage = result;
1018						ksbizExtInterface.setProperty("logoImage", KSBizConfig.logoImage, callback);    				
1019					} else {
1020						kslog("ksbizAct.loadLogoImage.result", "logoImage not exist");
1021						if(callback) callback(false);
1022					}
1023				});
1024			} else {
1025				if(callback) callback(true);
1026			}
1027    	};
1028    },
1029    
1030    setServerCert : function(callback){
1031		var setServerCertCallback = function(result, error){
1032			if(error){
1033				result = {};
1034				result.status = error.status;
1035				result.message = "[ksbizAct.setServerCert] SetServerCert Fail [" + error.status + "] " + error.message;
1036				callback(result);				
1037			} else {
1038				if(result){
1039					result = {};
1040					result.status = 1;
1041					callback(result);
1042				} else {
1043					result = {};
1044					result.status = "9999";
1045					result.message = "[ksbizAct.setServerCert] ServerCert SetProperty Fail";
1046					callback(result);				
1047				}
1048			}
1049		};
1050		var setServerCertError = function(){
1051			var result = {};
1052			result.status = "9999";
1053			result.message = "[ksbizAct.setServerCert] ServerCert not exist";
1054			callback(result);
1055		};
1056		
1057		if(KSBizConfig.serverCert){
1058			ksbizExtInterface.setProperty("serverCert", KSBizConfig.serverCert, setServerCertCallback);
1059    	} else {
1060    		if(KSBizConfig.serverCertUrl){
1061    			DC_get(KSBizConfig.serverCertUrl, "", function(svrCert){
1062    				if(svrCert){
1063						KSBizConfig.serverCert = svrCert;
1064						ksbizExtInterface.setProperty("serverCert", svrCert, setServerCertCallback);
1065    				} else {
1066    					setServerCertError();
1067    				}
1068    			});
1069    		} else {
1070    			setServerCertError();
1071    		}
1072    	}
1073    },
1074    
1075    setCACert : function(callback){
1076		var setCACertCallback = function(result, error){
1077			if(error){
1078				result = {};
1079				result.status = error.status;
1080				result.message = "[ksbizAct.setCACert] SetCACert Fail [" + error.status + "] " + error.message;
1081				callback(result);				
1082			} else {
1083				if(result){
1084					result = {};
1085					result.status = 1;
1086					callback(result);
1087				} else {
1088					result = {};
1089					result.status = "9999";
1090					result.message = "[ksbizAct.setCACert] CACert SetProperty Fail";
1091					callback(result);
1092				}
1093			}
1094		};
1095		var setCACertError = function(){
1096			var result = {};
1097			result.status = "9999";
1098			result.message = "[ksbizAct.setCACert] CACert not exist";
1099			callback(result);
1100		};
1101		
1102		if(KSBizConfig.caCert){
1103			ksbizExtInterface.setProperty("caCert", KSBizConfig.caCert, setCACertCallback);
1104    	} else {
1105    		if(KSBizConfig.caCertUrl){
1106    			DC_get(KSBizConfig.caCertUrl, "", function(caCert){
1107    				if(caCert){
1108    					KSBizConfig.caCert = caCert;
1109    					ksbizExtInterface.setProperty("caCert", caCert, setCACertCallback);
1110    				} else {
1111    					setCACertError();
1112    				}
1113    			});
1114    		} else {
1115    			setCACertError();
1116    		}
1117    	}
1118	},
1119	lineEncrypt : function(bucket){
1120		kslog("ksbizAct.lineEncrypt", bucket);
1121		var lineEncryptCallback = function(encStr, error){
1122			if(error){
1123				bucket.result = {};
1124				bucket.result.status = error.status;
1125				bucket.result.message = "[ksbizAct.lineEncrypt] lineEncrypt Fail : " + error.message; 
1126				bucket.bizcallback(bucket);
1127			} else {
1128				if(encStr){
1129					kslog("ksbizAct.lineEncrypt.encStr", encStr);
1130					bucket.result = {};
1131					bucket.result.status = "1";
1132					bucket.result.data = encStr;
1133					bucket.bizcallback(bucket);
1134				} else {
1135					bucket.result = {};
1136					bucket.result.status = "9999";
1137					bucket.result.message = "[ksbizAct.lineEncrypt] lineEncrypt Fail encStr not exist";
1138					bucket.bizcallback(bucket);
1139				}
1140			}
1141		} 
1142		//caCert
1143		if(!bucket.options.caCert) {
1144			if(KSBizConfig.caCert) {
1145				bucket.options.caCert = KSBizConfig.caCert;
1146			}
1147		}
1148		if(!KSBizConfig.serverCert || !KSBizConfig.serverSid){
1149			DC_get(KSBizConfig.lineServerURL, "", function(res){
1150				kslog("[ksbizAct.lineEncrypt.server]", res);
1151				if(res.length != ""){
1152					var resJSON = JSON.parse(res);
1153					var serverSid = resJSON.sid;
1154					var serverCert = resJSON.serverCert;
1155					//serverCert
1156					if(serverCert != ""){
1157						KSBizConfig.serverCert = serverCert;
1158						bucket.options.serverCert = KSBizConfig.serverCert;
1159						kslog("[ksbizAct.lineEncrypt.serverCert]",bucket.options.serverCert);
1160						//serverSid
1161						if(serverSid.length != 20){
1162							alert("암호화에 실패하였습니다. [serverSid 오류]");
1163						} else{
1164							KSBizConfig.serverSid = serverSid;
1165							bucket.options.serverSid = KSBizConfig.serverSid;
1166							kslog("[ksbizAct.lineEncrypt.bucket]", bucket);
1167							ksbizExtInterface.lineEncrypt(bucket.data, bucket.options, lineEncryptCallback);
1168						}
1169					} else{
1170						alert("서버 인증서를 가져올 수 없습니다.");
1171					}
1172				} else {
1173					alert("서버 인증서를 가져올 수 없습니다.");
1174				}
1175			});
1176		} else {
1177			bucket.options.serverCert = KSBizConfig.serverCert;
1178			bucket.options.serverSid = KSBizConfig.serverSid;
1179			ksbizExtInterface.lineEncrypt(bucket.data, bucket.options, lineEncryptCallback);
1180		}
1181	},
1182	lineDecryptAsync : function(bucket){
1183		kslog("ksbizAct.lineDecryptAsync", bucket);
1184		ksbizExtInterface.lineDecryptAsync(bucket.data, bucket.options, function(decStr, error){
1185			if(error){
1186				bucket.result = {};
1187				bucket.result.status = error.status;
1188				bucket.result.message = "[ksbizAct.lineDecryptAsync] lineDecryptAsync Fail : " + error.message; 
1189				bucket.bizcallback(bucket);
1190			} else {
1191				if(decStr){
1192					kslog("ksbizAct.lineDecryptAsync.decStr", decStr);
1193					bucket.result = {};
1194					bucket.result.status = "1";
1195					bucket.result.data = decStr;
1196					bucket.bizcallback(bucket);
1197				} else {
1198					bucket.result = {};
1199					bucket.result.status = "9999";
1200					bucket.result.message = "[ksbizAct.lineDecryptAsync] lineDecryptAsync Fail decStr not exist";
1201					bucket.bizcallback(bucket);
1202				}
1203			}
1204		});
1205	},
1206	simpleEncrypt : function(bucket){
1207		kslog("ksbizAct.simpleEncrypt", bucket);
1208		var simpleEncryptCallback = function(encStr, error){
1209			if(error){
1210				bucket.result = {};
1211				bucket.result.status = error.status;
1212				bucket.result.message = "[ksbizAct.simpleEncrypt] simpleEncrypt Fail : " + error.message; 
1213				bucket.bizcallback(bucket);
1214			} else {
1215				if(encStr){
1216					kslog("ksbizAct.simpleEncrypt.encStr", encStr);
1217					bucket.result = {};
1218					bucket.result.status = "1";
1219					bucket.result.data = encStr;
1220					bucket.bizcallback(bucket);
1221				} else {
1222					bucket.result = {};
1223					bucket.result.status = "9999";
1224					bucket.result.message = "[ksbizAct.simpleEncrypt] simpleEncrypt Fail encStr not exist";
1225					bucket.bizcallback(bucket);
1226				}
1227			}
1228		}
1229		//caCert
1230		if(!bucket.options.caCert) {
1231			if(KSBizConfig.caCert) {
1232				bucket.options.caCert = KSBizConfig.caCert;
1233			}
1234		}
1235		//serverCert
1236		if(!bucket.options.serverCert){
1237			if(KSBizConfig.serverCert == ""){
1238				DC_get(KSBizConfig.serverCertUrl, "", function(serverCert){
1239					kslog("[ksbizAct.simpleEncrypt.server]", serverCert);
1240					if(serverCert.length != ""){
1241						KSBizConfig.serverCert = serverCert;
1242						bucket.options.serverCert = KSBizConfig.serverCert;
1243						ksbizExtInterface.simpleEncrypt(bucket.data, bucket.options, simpleEncryptCallback);
1244					} else{
1245						alert("서버 인증서를 가져올 수 없습니다.");
1246					}
1247				});
1248			} else{
1249				bucket.options.serverCert = KSBizConfig.serverCert;
1250				ksbizExtInterface.simpleEncrypt(bucket.data, bucket.options, simpleEncryptCallback);
1251			}		
1252		}
1253	},
1254	simpleDecryptAsync : function(bucket){
1255		kslog("ksbizAct.simpleDecryptAsync", bucket);
1256		ksbizExtInterface.simpleDecryptAsync(bucket.data, bucket.options, function(decStr, error){
1257			if(error){
1258				bucket.result = {};
1259				bucket.result.status = error.status;
1260				bucket.result.message = "[ksbizAct.simpleDecryptAsync] simpleDecryptAsync Fail : " + error.message; 
1261				bucket.bizcallback(bucket);
1262			} else {
1263				if(decStr){
1264					kslog("ksbizAct.simpleDecryptAsync.decStr", decStr);
1265					bucket.result = {};
1266					bucket.result.status = "1";
1267					bucket.result.data = decStr;
1268					bucket.bizcallback(bucket);
1269				} else {
1270					bucket.result = {};
1271					bucket.result.status = "9999";
1272					bucket.result.message = "[ksbizAct.simpleDecryptAsync] simpleDecryptAsync Fail decStr not exist";
1273					bucket.bizcallback(bucket);
1274				}
1275			}
1276		});
1277	}
1278};

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.