00001 using System;
00002 using System.Collections;
00003 using DKMSCryptoCore;
00004 using DKMSProtocol;
00005 using DKMSErrorManager;
00006
00015 namespace CryptoService
00016 {
00021 public class Dispatcher
00022 {
00023 #region Dispatcher class methods
00024
00028 public Dispatcher()
00029 {
00030 #if DEBUG
00031
00032 _c = TestCryptoService._c;
00033
00034 _cc = TestCryptoService._cc;
00035 #else
00036
00037 _c = Service._c;
00038
00039 _cc = Service._cc;
00040 #endif
00041
00042
00043 _stmf = new CryptoCore.Stmf(_cc);
00044
00045
00046 _smf = new CryptoCore.Smf(_cc);
00047
00048
00049 _pm = new ProtocolManager(_cc.HostInfo.Info);
00050 }
00051
00057 public void CS_Dispacher(string RxProtocolBlock, out string TxProtocolBlock)
00058 {
00059 UInt32 ret = ErrorManager.DKMS_OK;
00060
00061
00062
00063 TxProtocolBlock = string.Empty;
00064
00066
00067 _pm.RxProtocolBlock = RxProtocolBlock;
00068 ret = _pm.XMLRXParser(out config);
00069 if(ret != ErrorManager.DKMS_OK)
00070 {
00071 _pm.XMLTXParser_Set_Error(ret);
00072 TxProtocolBlock = _pm.TxProtocolBlock;
00073 }
00074 else
00075 {
00076
00077 ret = _pm.VerifyDataIntegrity(config.security.hashValue);
00078 if(ret != ErrorManager.DKMS_OK)
00079 {
00080 _pm.XMLTXParser_Set_Error(ret);
00081 TxProtocolBlock = _pm.TxProtocolBlock;
00082 }
00083 else
00084 {
00085
00086 string delimStr = "|";
00087 char[] delimiter = delimStr.ToCharArray();
00088 string[] groups = config.header.userName.Split(delimiter);
00089 string group = string.Empty;
00090 Hashtable currentgroup = new Hashtable(20, 0.1f);
00091
00092 if (groups.Length != 2)
00093 {
00094 ret = ErrorManager.DKMS_ACCESS_DENIED;
00095 _pm.XMLTXParser_Set_Error(ret);
00096 TxProtocolBlock = _pm.TxProtocolBlock;
00097 }
00098 else
00099 {
00100 if (groups[1]== "dkms_operators")
00101 currentgroup = _c.operatorsgc.SyncOGContainer;
00102 else if (groups[1] == "dkms_technicians")
00103 currentgroup = _c.techniciansgc.SyncTGContainer;
00104 else if (groups[1] == "dkms_swdevelopers")
00105 currentgroup = _c.swdevelopersgc.SyncSGContainer;
00106 else if (groups[1] == "dkms_inserters")
00107 currentgroup = _c.insertersgc.SyncIGContainer;
00108 else if (groups[1] == "dkms_custodians")
00109 currentgroup = _c.custodiansgc.SyncCGContainer;
00110 else if (groups[1] == "dkms_controllers")
00111 currentgroup = _c.controllersgc.SyncCGContainer;
00112 else if (groups[1] == "dkms_admins")
00113 currentgroup = _c.adminsgc.SyncAGContainer;
00114 else if (groups[1] == "dkms_swadmins")
00115 currentgroup = _c.swadminsgc.SyncSGContainer;
00116 else
00117 {
00118 ret = ErrorManager.DKMS_ACCESS_DENIED;
00119 _pm.XMLTXParser_Set_Error(ret);
00120 TxProtocolBlock = _pm.TxProtocolBlock;
00121 }
00122
00123 if (ret == ErrorManager.DKMS_OK)
00124 {
00126
00127 switch (config.body.cmdName)
00128 {
00129 case "DKMS_OpenSession":
00130 if (currentgroup.ContainsKey("OpenSession"))
00131 {
00132 CS_OpenSession();
00133 }
00134 else
00135 ret = ErrorManager.DKMS_ACCESS_DENIED;
00136 break;
00137 case "DKMS_CloseSession":
00138 if (currentgroup.ContainsKey("CloseSession"))
00139 {
00140 CS_CloseSession();
00141 }
00142 else
00143 ret = ErrorManager.DKMS_ACCESS_DENIED;
00144 break;
00145 case "DKMS_GetSessionInfo":
00146 if (currentgroup.ContainsKey("GetSessionInfo"))
00147 {
00148 CS_GetSessionInfo();
00149 }
00150 else
00151 ret = ErrorManager.DKMS_ACCESS_DENIED;
00152 break;
00153 case "DKMS_Login":
00154 if (currentgroup.ContainsKey("Login"))
00155 {
00156 CS_Login();
00157 }
00158 else
00159 ret = ErrorManager.DKMS_ACCESS_DENIED;
00160 break;
00161 case "DKMS_Logout":
00162 if (currentgroup.ContainsKey("Logout"))
00163 {
00164 CS_Logout();
00165 }
00166 else
00167 ret = ErrorManager.DKMS_ACCESS_DENIED;
00168 break;
00169 case "DKMS_CreateObject":
00170 if (currentgroup.ContainsKey("CreateObject"))
00171 {
00172 CS_CreateObject();
00173 }
00174 else
00175 ret = ErrorManager.DKMS_ACCESS_DENIED;
00176 break;
00177 case "DKMS_FindObjectsInit":
00178 if (currentgroup.ContainsKey("FindObjectsInit"))
00179 {
00180 CS_FindObjectsInit();
00181 }
00182 else
00183 ret = ErrorManager.DKMS_ACCESS_DENIED;
00184 break;
00185 case "DKMS_FindObjects":
00186 if (currentgroup.ContainsKey("FindObjects"))
00187 {
00188 CS_FindObjects();
00189 }
00190 else
00191 ret = ErrorManager.DKMS_ACCESS_DENIED;
00192 break;
00193 case "DKMS_FindObjectsFinal":
00194 if (currentgroup.ContainsKey("FindObjectsFinal"))
00195 {
00196 CS_FindObjectsFinal();
00197 }
00198 else
00199 ret = ErrorManager.DKMS_ACCESS_DENIED;
00200 break;
00201 case "DKMS_CompactFindObjects":
00202 if (currentgroup.ContainsKey("CompactFindObjects"))
00203 {
00204 CS_CompactFindObjects();
00205 }
00206 else
00207 ret = ErrorManager.DKMS_ACCESS_DENIED;
00208 break;
00209 case "DKMS_EncryptInit":
00210 if (currentgroup.ContainsKey("EncryptInit"))
00211 {
00212 CS_EncryptInit();
00213 }
00214 else
00215 ret = ErrorManager.DKMS_ACCESS_DENIED;
00216 break;
00217 case "DKMS_Encrypt":
00218 if (currentgroup.ContainsKey("Encrypt"))
00219 {
00220 CS_Encrypt();
00221 }
00222 else
00223 ret = ErrorManager.DKMS_ACCESS_DENIED;
00224 break;
00225 case "DKMS_CompactEncrypt":
00226 if (currentgroup.ContainsKey("CompactEncrypt"))
00227 {
00228 CS_CompactEncrypt();
00229 }
00230 else
00231 ret = ErrorManager.DKMS_ACCESS_DENIED;
00232 break;
00233 case "DKMS_EncryptUpdate":
00234 if (currentgroup.ContainsKey("EncryptUpdate"))
00235 {
00236 CS_EncryptUpdate();
00237 }
00238 else
00239 ret = ErrorManager.DKMS_ACCESS_DENIED;
00240 break;
00241 case "DKMS_EncryptFinal":
00242 if (currentgroup.ContainsKey("EncryptFinal"))
00243 {
00244 CS_EncryptFinal();
00245 }
00246 else
00247 ret = ErrorManager.DKMS_ACCESS_DENIED;
00248 break;
00249 case "DKMS_DecryptInit":
00250 if (currentgroup.ContainsKey("DecryptInit"))
00251 {
00252 CS_DecryptInit();
00253 }
00254 else
00255 ret = ErrorManager.DKMS_ACCESS_DENIED;
00256 break;
00257 case "DKMS_Decrypt":
00258 if (currentgroup.ContainsKey("Decrypt"))
00259 {
00260 CS_Decrypt();
00261 }
00262 else
00263 ret = ErrorManager.DKMS_ACCESS_DENIED;
00264 break;
00265 case "DKMS_CompactDecrypt":
00266 if (currentgroup.ContainsKey("CompactDecrypt"))
00267 {
00268 CS_CompactDecrypt();
00269 }
00270 else
00271 ret = ErrorManager.DKMS_ACCESS_DENIED;
00272 break;
00273 case "DKMS_DecryptUpdate":
00274 if (currentgroup.ContainsKey("DecryptUpdate"))
00275 {
00276 CS_DecryptUpdate();
00277 }
00278 else
00279 ret = ErrorManager.DKMS_ACCESS_DENIED;
00280 break;
00281 case "DKMS_DecryptFinal":
00282 if (currentgroup.ContainsKey("DecryptFinal"))
00283 {
00284 CS_DecryptFinal();
00285 }
00286 else
00287 ret = ErrorManager.DKMS_ACCESS_DENIED;
00288 break;
00289 case "DKMS_GetInfo":
00290 if (currentgroup.ContainsKey("GetInfo"))
00291 {
00292 CS_GetInfo();
00293 }
00294 else
00295 ret = ErrorManager.DKMS_ACCESS_DENIED;
00296 break;
00297 case "DKMS_GetTokenInfo":
00298 if (currentgroup.ContainsKey("GetTokenInfo"))
00299 {
00300 CS_GetTokenInfo();
00301 }
00302 else
00303 ret = ErrorManager.DKMS_ACCESS_DENIED;
00304 break;
00305 case "DKMS_SeedRandom":
00306 if (currentgroup.ContainsKey("SeedRandom"))
00307 {
00308 CS_SeedRandom();
00309 }
00310 else
00311 ret = ErrorManager.DKMS_ACCESS_DENIED;
00312 break;
00313 case "DKMS_GenerateRandom":
00314 if (currentgroup.ContainsKey("GenerateRandom"))
00315 {
00316 CS_GenerateRandom();
00317 }
00318 else
00319 ret = ErrorManager.DKMS_ACCESS_DENIED;
00320 break;
00321 case "DKMS_CompactGenerateRandom":
00322 if (currentgroup.ContainsKey("CompactGenerateRandom"))
00323 {
00324 CS_CompactGenerateRandom();
00325 }
00326 else
00327 ret = ErrorManager.DKMS_ACCESS_DENIED;
00328 break;
00329 case "DKMS_DestroyObject":
00330 if (currentgroup.ContainsKey("DestroyObject"))
00331 {
00332 CS_DestroyObject();
00333 }
00334 else
00335 ret = ErrorManager.DKMS_ACCESS_DENIED;
00336 break;
00337 case "DKMS_GetMechanismList":
00338 if (currentgroup.ContainsKey("GetMechanismList"))
00339 {
00340 CS_GetMechanismList();
00341 }
00342 else
00343 ret = ErrorManager.DKMS_ACCESS_DENIED;
00344 break;
00345 case "DKMS_GetAttributeValue":
00346 if (currentgroup.ContainsKey("GetAttributeValue"))
00347 {
00348 CS_GetAttributeValue();
00349 }
00350 else
00351 ret = ErrorManager.DKMS_ACCESS_DENIED;
00352 break;
00353 case "DKMS_DigestInit":
00354 if (currentgroup.ContainsKey("DigestInit"))
00355 {
00356 CS_DigestInit();
00357 }
00358 else
00359 ret = ErrorManager.DKMS_ACCESS_DENIED;
00360 break;
00361 case "DKMS_Digest":
00362 if (currentgroup.ContainsKey("Digest"))
00363 {
00364 CS_Digest();
00365 }
00366 else
00367 ret = ErrorManager.DKMS_ACCESS_DENIED;
00368 break;
00369 case "DKMS_CompactDigest":
00370 if (currentgroup.ContainsKey("CompactDigest"))
00371 {
00372 CS_CompactDigest();
00373 }
00374 else
00375 ret = ErrorManager.DKMS_ACCESS_DENIED;
00376 break;
00377 case "DKMS_DigestUpdate":
00378 if (currentgroup.ContainsKey("DigestUpdate"))
00379 {
00380 CS_DigestUpdate();
00381 }
00382 else
00383 ret = ErrorManager.DKMS_ACCESS_DENIED;
00384 break;
00385 case "DKMS_DigestKey":
00386 if (currentgroup.ContainsKey("DigestKey"))
00387 {
00388 CS_DigestKey();
00389 }
00390 else
00391 ret = ErrorManager.DKMS_ACCESS_DENIED;
00392 break;
00393 case "DKMS_DigestFinal":
00394 if (currentgroup.ContainsKey("DigestFinal"))
00395 {
00396 CS_DigestFinal();
00397 }
00398 else
00399 ret = ErrorManager.DKMS_ACCESS_DENIED;
00400 break;
00401 case "DKMS_SignInit":
00402 if (currentgroup.ContainsKey("SignInit"))
00403 {
00404 CS_SignInit();
00405 }
00406 else
00407 ret = ErrorManager.DKMS_ACCESS_DENIED;
00408 break;
00409 case "DKMS_Sign":
00410 if (currentgroup.ContainsKey("Sign"))
00411 {
00412 CS_Sign();
00413 }
00414 else
00415 ret = ErrorManager.DKMS_ACCESS_DENIED;
00416 break;
00417 case "DKMS_CompactSign":
00418 if (currentgroup.ContainsKey("CompactSign"))
00419 {
00420 CS_CompactSign();
00421 }
00422 else
00423 ret = ErrorManager.DKMS_ACCESS_DENIED;
00424 break;
00425 case "DKMS_SignUpdate":
00426 if (currentgroup.ContainsKey("SignUpdate"))
00427 {
00428 CS_SignUpdate();
00429 }
00430 else
00431 ret = ErrorManager.DKMS_ACCESS_DENIED;
00432 break;
00433 case "DKMS_SignFinal":
00434 if (currentgroup.ContainsKey("SignFinal"))
00435 {
00436 CS_SignFinal();
00437 }
00438 else
00439 ret = ErrorManager.DKMS_ACCESS_DENIED;
00440 break;
00441 case "DKMS_SignRecoverInit":
00442 if (currentgroup.ContainsKey("SignRecoverInit"))
00443 {
00444 CS_SignRecoverInit();
00445 }
00446 else
00447 ret = ErrorManager.DKMS_ACCESS_DENIED;
00448 break;
00449 case "DKMS_SignRecover":
00450 if (currentgroup.ContainsKey("SignRecover"))
00451 {
00452 CS_SignRecover();
00453 }
00454 else
00455 ret = ErrorManager.DKMS_ACCESS_DENIED;
00456 break;
00457 case "DKMS_CompactSignRecover":
00458 if (currentgroup.ContainsKey("CompactSignRecover"))
00459 {
00460 CS_CompactSignRecover();
00461 }
00462 else
00463 ret = ErrorManager.DKMS_ACCESS_DENIED;
00464 break;
00465 case "DKMS_VerifyInit":
00466 if (currentgroup.ContainsKey("VerifyInit"))
00467 {
00468 CS_VerifyInit();
00469 }
00470 else
00471 ret = ErrorManager.DKMS_ACCESS_DENIED;
00472 break;
00473 case "DKMS_Verify":
00474 if (currentgroup.ContainsKey("Verify"))
00475 {
00476 CS_Verify();
00477 }
00478 else
00479 ret = ErrorManager.DKMS_ACCESS_DENIED;
00480 break;
00481 case "DKMS_CompactVerify":
00482 if (currentgroup.ContainsKey("CompactVerify"))
00483 {
00484 CS_CompactVerify();
00485 }
00486 else
00487 ret = ErrorManager.DKMS_ACCESS_DENIED;
00488 break;
00489 case "DKMS_VerifyUpdate":
00490 if (currentgroup.ContainsKey("VerifyUpdate"))
00491 {
00492 CS_VerifyUpdate();
00493 }
00494 else
00495 ret = ErrorManager.DKMS_ACCESS_DENIED;
00496 break;
00497 case "DKMS_VerifyFinal":
00498 if (currentgroup.ContainsKey("VerifyFinal"))
00499 {
00500 CS_VerifyFinal();
00501 }
00502 else
00503 ret = ErrorManager.DKMS_ACCESS_DENIED;
00504 break;
00505 case "DKMS_VerifyRecoverInit":
00506 if (currentgroup.ContainsKey("VerifyRecoverInit"))
00507 {
00508 CS_VerifyRecoverInit();
00509 }
00510 else
00511 ret = ErrorManager.DKMS_ACCESS_DENIED;
00512 break;
00513 case "DKMS_VerifyRecover":
00514 if (currentgroup.ContainsKey("VerifyRecover"))
00515 {
00516 CS_VerifyRecover();
00517 }
00518 else
00519 ret = ErrorManager.DKMS_ACCESS_DENIED;
00520 break;
00521 case "DKMS_CompactVerifyRecover":
00522 if (currentgroup.ContainsKey("CompactVerifyRecover"))
00523 {
00524 CS_CompactVerifyRecover();
00525 }
00526 else
00527 ret = ErrorManager.DKMS_ACCESS_DENIED;
00528 break;
00529 case "DKMS_DigestEncryptUpdate":
00530 if (currentgroup.ContainsKey("DigestEncryptUpdate"))
00531 {
00532 CS_DigestEncryptUpdate();
00533 }
00534 else
00535 ret = ErrorManager.DKMS_ACCESS_DENIED;
00536 break;
00537 case "DKMS_DecryptDigestUpdate":
00538 if (currentgroup.ContainsKey("DecryptDigestUpdate"))
00539 {
00540 CS_DecryptDigestUpdate();
00541 }
00542 else
00543 ret = ErrorManager.DKMS_ACCESS_DENIED;
00544 break;
00545 case "DKMS_SignEncryptUpdate":
00546 if (currentgroup.ContainsKey("SignEncryptUpdate"))
00547 {
00548 CS_SignEncryptUpdate();
00549 }
00550 else
00551 ret = ErrorManager.DKMS_ACCESS_DENIED;
00552 break;
00553 case "DKMS_DecryptVerifyUpdate":
00554 if (currentgroup.ContainsKey("DecryptVerifyUpdate"))
00555 {
00556 CS_DecryptVerifyUpdate();
00557 }
00558 else
00559 ret = ErrorManager.DKMS_ACCESS_DENIED;
00560 break;
00561 case "DKMS_GenerateKey":
00562 if (currentgroup.ContainsKey("GenerateKey"))
00563 {
00564 CS_GenerateKey();
00565 }
00566 else
00567 ret = ErrorManager.DKMS_ACCESS_DENIED;
00568 break;
00569 case "DKMS_GenerateKeyPair":
00570 if (currentgroup.ContainsKey("GenerateKeyPair"))
00571 {
00572 CS_GenerateKeyPair();
00573 }
00574 else
00575 ret = ErrorManager.DKMS_ACCESS_DENIED;
00576 break;
00577 case "DKMS_WrapKey":
00578 if (currentgroup.ContainsKey("WrapKey"))
00579 {
00580 CS_WrapKey();
00581 }
00582 else
00583 ret = ErrorManager.DKMS_ACCESS_DENIED;
00584 break;
00585 case "DKMS_UnwrapKey":
00586 if (currentgroup.ContainsKey("UnwrapKey"))
00587 {
00588 CS_UnwrapKey();
00589 }
00590 else
00591 ret = ErrorManager.DKMS_ACCESS_DENIED;
00592 break;
00593 case "DKMS_DeriveKey":
00594 if (currentgroup.ContainsKey("DeriveKey"))
00595 {
00596 CS_DeriveKey();
00597 }
00598 else
00599 ret = ErrorManager.DKMS_ACCESS_DENIED;
00600 break;
00601 case "DKMS_SetAttributeValue":
00602 if (currentgroup.ContainsKey("SetAttributeValue"))
00603 {
00604 CS_SetAttributeValue();
00605 }
00606 else
00607 ret = ErrorManager.DKMS_ACCESS_DENIED;
00608 break;
00609 case "DKMS_GetObjectSize":
00610 if (currentgroup.ContainsKey("GetObjectSize"))
00611 {
00612 CS_GetObjectSize();
00613 }
00614 else
00615 ret = ErrorManager.DKMS_ACCESS_DENIED;
00616 break;
00617 case "DKMS_SetPIN":
00618 if (currentgroup.ContainsKey("SetPIN"))
00619 {
00620 CS_SetPIN();
00621 }
00622 else
00623 ret = ErrorManager.DKMS_ACCESS_DENIED;
00624 break;
00625 case "DKMS_InitPIN":
00626 if (currentgroup.ContainsKey("InitPIN"))
00627 {
00628 CS_InitPIN();
00629 }
00630 else
00631 ret = ErrorManager.DKMS_ACCESS_DENIED;
00632 break;
00633 case "DKMS_InitToken":
00634 if (currentgroup.ContainsKey("InitToken"))
00635 {
00636 CS_InitToken();
00637 }
00638 else
00639 ret = ErrorManager.DKMS_ACCESS_DENIED;
00640 break;
00641 case "DKMS_GetMechanismInfo":
00642 if (currentgroup.ContainsKey("GetMechanismInfo"))
00643 {
00644 CS_GetMechanismInfo();
00645 }
00646 else
00647 ret = ErrorManager.DKMS_ACCESS_DENIED;
00648 break;
00649 case "DKMS_GetSlotInfo":
00650 if (currentgroup.ContainsKey("GetSlotInfo"))
00651 {
00652 CS_GetSlotInfo();
00653 }
00654 else
00655 ret = ErrorManager.DKMS_ACCESS_DENIED;
00656 break;
00657 case "DKMS_GetSlotList":
00658 if (currentgroup.ContainsKey("GetSlotList"))
00659 {
00660 CS_GetSlotList();
00661 }
00662 else
00663 ret = ErrorManager.DKMS_ACCESS_DENIED;
00664 break;
00665 case "DKMS_TestDeviceComunication":
00666 if (currentgroup.ContainsKey("TestDeviceComunication"))
00667 {
00668 CS_TestDeviceComunication();
00669 }
00670 else
00671 ret = ErrorManager.DKMS_ACCESS_DENIED;
00672 break;
00673 case "DKMS_SetPolicy":
00674 if (currentgroup.ContainsKey("SetPolicy"))
00675 {
00676 lock (_c.adminsgc.SyncAGContainer.SyncRoot)
00677 {
00678 lock (_c.controllersgc.SyncCGContainer.SyncRoot)
00679 {
00680 lock (_c.custodiansgc.SyncCGContainer.SyncRoot)
00681 {
00682 lock (_c.insertersgc.SyncIGContainer.SyncRoot)
00683 {
00684 lock (_c.operatorsgc.SyncOGContainer.SyncRoot)
00685 {
00686 lock (_c.swadminsgc.SyncSGContainer.SyncRoot)
00687 {
00688 lock (_c.swdevelopersgc.SyncSGContainer.SyncRoot)
00689 {
00690 lock (_c.techniciansgc.SyncTGContainer.SyncRoot)
00691 {
00692 CS_SetPolicy();
00693 }
00694 }
00695 }
00696 }
00697 }
00698 }
00699 }
00700 }
00701 }
00702 else
00703 ret = ErrorManager.DKMS_ACCESS_DENIED;
00704 break;
00705
00706 default:
00707 ret = ErrorManager.DKMS_FUNCTION_NOT_FOUND;
00708 break;
00709 }
00710
00711
00712 if (ret != ErrorManager.DKMS_OK)
00713 _pm.XMLTXParser_Set_Error(ret);
00714
00715
00716 TxProtocolBlock = _pm.TxProtocolBlock;
00717 }
00718 }
00719 }
00720 }
00721 }
00722
00727 private void CS_OpenSession()
00728 {
00729 UInt32 ret = ErrorManager.DKMS_OK;
00730
00731 UInt32 slotID;
00732 CryptoCore.Smf.SESSION_INFO_FLAGS flags;
00733
00734
00736
00737
00739
00740 slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
00741
00742 flags = (CryptoCore.Smf.SESSION_INFO_FLAGS)int.Parse(((ProtocolManager.Param)config.body.param["flags"]).vvalue);
00743
00744
00745 ret = _smf.OpenSession(slotID, flags);
00746
00747
00748 if(ret != ErrorManager.DKMS_OK)
00749 {
00750 _pm.XMLTXParser_Set_Error(ret);
00751 }
00752
00753 else
00754 {
00755
00756 lock (_c.csc.SyncCSContainer.SyncRoot)
00757 {
00758 UInt32 ss = (UInt32)_c.csc.SyncCSContainer["sessions"];
00759 ss++;
00760 _c.csc.SyncCSContainer["sessions"] = ss;
00761 }
00762
00764
00765
00766 _pm.XMLTXParser_Set_Start("DKMS_OpenSession", 2);
00767
00768 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00769 _pm.XMLTXParser_Set_ParamAtomic(1, "CurrentSession", ProtocolManager.PARAM_TYPE.UINT32, _smf.CurrentSession.ToString());
00770
00771 _pm.XMLTXParser_Set_End();
00772 }
00773 }
00774
00779 private void CS_CloseSession()
00780 {
00781 UInt32 ret = ErrorManager.DKMS_OK;
00782
00783 UInt32 hSession;
00784
00785
00787
00788
00790
00791 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00792
00793
00794 ret = _smf.CloseSession(hSession);
00795
00796
00797 if(ret != ErrorManager.DKMS_OK)
00798 {
00799 _pm.XMLTXParser_Set_Error(ret);
00800 }
00801
00802 else
00803 {
00804
00805 lock (_c.csc.SyncCSContainer.SyncRoot)
00806 {
00807 UInt32 ss = (UInt32)_c.csc.SyncCSContainer["sessions"];
00808 if (ss > 0)
00809 {
00810 ss--;
00811 _c.csc.SyncCSContainer["sessions"] = ss;
00812 }
00813 if (ss == 0)
00814 {
00815 _cc.Finalize();
00816 _cc.Initialize(true);
00817 }
00818 }
00819
00821
00822
00823 _pm.XMLTXParser_Set_Start("DKMS_CloseSession", 1);
00824
00825 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00826
00827 _pm.XMLTXParser_Set_End();
00828 }
00829 }
00830
00834 private void CS_GetSessionInfo()
00835 {
00836 UInt32 ret = ErrorManager.DKMS_OK;
00837
00838 UInt32 hSession;
00839
00840 CryptoCore.Smf.CK_SESSION_INFO pInfo;
00841
00842
00844
00845
00847
00848 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00849 _smf.CurrentSession = hSession;
00850
00852
00854
00855 pInfo = new CryptoCore.Smf.CK_SESSION_INFO();
00856
00857
00858 ret = _smf.GetSessionInfo(out pInfo);
00859
00860
00861 if(ret != ErrorManager.DKMS_OK)
00862 {
00863 _pm.XMLTXParser_Set_Error(ret);
00864 }
00865
00866 else
00867 {
00869
00870
00871 _pm.XMLTXParser_Set_Start("DKMS_GetSessionInfo", 2);
00872
00873 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00874 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
00875 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
00876 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.slotID", ProtocolManager.PARAM_TYPE.UINT32, pInfo.slotID.ToString());
00877 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.state", ProtocolManager.PARAM_TYPE.UINT32, pInfo.state.ToString());
00878 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.ulDeviceError", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulDeviceError.ToString());
00879 _pm.XMLTXParser_Set_EndParamStruct();
00880
00881 _pm.XMLTXParser_Set_End();
00882 }
00883 }
00884
00888 private void CS_Login()
00889 {
00890 UInt32 ret = ErrorManager.DKMS_OK;
00891
00892 UInt32 hSession;
00893 CryptoCore.Smf.CK_USER_TYPE userType;
00894 string Pin;
00895
00896
00898
00899
00901
00902 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00903 _smf.CurrentSession = hSession;
00904
00905 userType = (CryptoCore.Smf.CK_USER_TYPE)int.Parse(((ProtocolManager.Param)config.body.param["userType"]).vvalue);
00906
00907 Pin = ((ProtocolManager.Param)config.body.param["Pin"]).vvalue;
00908
00909
00910 ret = _smf.Login(userType, Pin);
00911
00912
00913 if(ret != ErrorManager.DKMS_OK)
00914 {
00915 _pm.XMLTXParser_Set_Error(ret);
00916 }
00917
00918 else
00919 {
00921
00922
00923 _pm.XMLTXParser_Set_Start("DKMS_Login", 1);
00924
00925 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00926
00927 _pm.XMLTXParser_Set_End();
00928 }
00929 }
00930
00934 private void CS_Logout()
00935 {
00936 UInt32 ret = ErrorManager.DKMS_OK;
00937
00938 UInt32 hSession;
00939
00940
00942
00943
00945
00946 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00947 _smf.CurrentSession = hSession;
00948
00949
00950 ret = _smf.Logout();
00951
00952
00953 if(ret != ErrorManager.DKMS_OK)
00954 {
00955 _pm.XMLTXParser_Set_Error(ret);
00956 }
00957
00958 else
00959 {
00961
00962
00963 _pm.XMLTXParser_Set_Start("DKMS_Logout", 1);
00964
00965 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
00966
00967 _pm.XMLTXParser_Set_End();
00968 }
00969 }
00970
00974 private void CS_CreateObject()
00975 {
00976 UInt32 ret = ErrorManager.DKMS_OK;
00977 CryptoCore.CCConvert converter;
00978 UInt32 ulCount;
00979
00980 UInt32 hSession;
00981 CryptoCore.ATTRIBUTE_VALUE templ;
00982
00983 UInt32 phObject;
00984
00985
00986
00987 converter = new CryptoCore.CCConvert();
00988
00990
00991
00993
00994 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
00995 _smf.CurrentSession = hSession;
00996
00997 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
00998 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
00999
01000
01001 if(ret != ErrorManager.DKMS_OK)
01002 {
01003 _pm.XMLTXParser_Set_Error(ret);
01004 }
01005
01006 else
01007 {
01008
01009 ret = _smf.omf.CreateObject(templ, out phObject);
01010
01011
01012 if(ret != ErrorManager.DKMS_OK)
01013 {
01014 _pm.XMLTXParser_Set_Error(ret);
01015 }
01016
01017 else
01018 {
01020
01021
01022 _pm.XMLTXParser_Set_Start("DKMS_CreateObject", 2);
01023
01024 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01025 _pm.XMLTXParser_Set_ParamAtomic(1, "phObject", ProtocolManager.PARAM_TYPE.UINT32, phObject.ToString());
01026
01027 _pm.XMLTXParser_Set_End();
01028 }
01029 }
01030 }
01031
01036 private void CS_FindObjectsInit()
01037 {
01038 UInt32 ret = ErrorManager.DKMS_OK;
01039 CryptoCore.CCConvert converter;
01040 UInt32 ulCount;
01041
01042 UInt32 hSession;
01043 CryptoCore.ATTRIBUTE_VALUE templ;
01044
01045
01046
01047 converter = new CryptoCore.CCConvert();
01048
01050
01051
01053
01054 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01055 _smf.CurrentSession = hSession;
01056
01057 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
01058 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
01059
01060
01061 if(ret != ErrorManager.DKMS_OK)
01062 {
01063 _pm.XMLTXParser_Set_Error(ret);
01064 }
01065
01066 else
01067 {
01068
01069 ret = _smf.omf.FindObjectsInit(templ);
01070
01071
01072 if(ret != ErrorManager.DKMS_OK)
01073 {
01074 _pm.XMLTXParser_Set_Error(ret);
01075 }
01076
01077 else
01078 {
01080
01081
01082 _pm.XMLTXParser_Set_Start("DKMS_FindObjectsInit", 1);
01083
01084 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01085
01086 _pm.XMLTXParser_Set_End();
01087 }
01088 }
01089 }
01090
01095 private void CS_FindObjects()
01096 {
01097 UInt32 ret = ErrorManager.DKMS_OK;
01098
01099 UInt32 hSession;
01100 int maxObjectNumber;
01101
01102 UInt32[] hObject;
01103
01104
01106
01107
01109
01110 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01111 _smf.CurrentSession = hSession;
01112
01113 maxObjectNumber = int.Parse(((ProtocolManager.Param)config.body.param["maxObjectNumber"]).vvalue);
01114
01115
01116 ret = _smf.omf.FindObjects(out hObject, maxObjectNumber);
01117
01118
01119 if(ret != ErrorManager.DKMS_OK)
01120 {
01121 _pm.XMLTXParser_Set_Error(ret);
01122 }
01123
01124 else
01125 {
01127
01128
01129 _pm.XMLTXParser_Set_Start("DKMS_FindObjects", 2);
01130
01131 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01132 _pm.XMLTXParser_Set_StartParamArray(1, "hObject", ProtocolManager.PARAM_TYPE.UINT32, (UInt32)hObject.Length, 0);
01133 for (int i = 0; i < hObject.Length; i++)
01134 _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "hObject[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.UINT32, hObject[i].ToString());
01135 _pm.XMLTXParser_Set_EndParamArray();
01136
01137 _pm.XMLTXParser_Set_End();
01138 }
01139 }
01140
01144 private void CS_FindObjectsFinal()
01145 {
01146 UInt32 ret = ErrorManager.DKMS_OK;
01147
01148 UInt32 hSession;
01149
01150
01152
01153
01155
01156 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01157 _smf.CurrentSession = hSession;
01158
01159
01160 ret = _smf.omf.FindObjectsFinal();
01161
01162
01163 if(ret != ErrorManager.DKMS_OK)
01164 {
01165 _pm.XMLTXParser_Set_Error(ret);
01166 }
01167
01168 else
01169 {
01171
01172
01173 _pm.XMLTXParser_Set_Start("DKMS_FindObjectsFinal", 1);
01174
01175 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01176
01177 _pm.XMLTXParser_Set_End();
01178 }
01179 }
01180
01185 private void CS_CompactFindObjects()
01186 {
01187 UInt32 ret = ErrorManager.DKMS_OK;
01188 CryptoCore.CCConvert converter;
01189 UInt32 ulCount;
01190
01191 UInt32 hSession;
01192 int maxObjectNumber;
01193 CryptoCore.ATTRIBUTE_VALUE templ;
01194
01195 UInt32[] hObject;
01196
01197
01198
01199 converter = new CryptoCore.CCConvert();
01200
01202
01203
01204
01206
01207 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01208 _smf.CurrentSession = hSession;
01209
01210 maxObjectNumber = int.Parse(((ProtocolManager.Param)config.body.param["maxObjectNumber"]).vvalue);
01211
01212 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
01213 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
01214
01215
01216 if(ret != ErrorManager.DKMS_OK)
01217 {
01218 _pm.XMLTXParser_Set_Error(ret);
01219 }
01220
01221 else
01222 {
01223
01224 ret = _smf.omf.CompactFindObjects(templ, out hObject, maxObjectNumber);
01225
01226
01227 if (ret != ErrorManager.DKMS_OK)
01228 {
01229 _pm.XMLTXParser_Set_Error(ret);
01230 }
01231
01232 else
01233 {
01235
01236
01237 _pm.XMLTXParser_Set_Start("DKMS_CompactFindObjects", 2);
01238
01239 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01240 _pm.XMLTXParser_Set_StartParamArray(1, "hObject", ProtocolManager.PARAM_TYPE.UINT32, (UInt32)hObject.Length, 0);
01241 for (int i = 0; i < hObject.Length; i++)
01242 _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "hObject[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.UINT32, hObject[i].ToString());
01243 _pm.XMLTXParser_Set_EndParamArray();
01244
01245 _pm.XMLTXParser_Set_End();
01246 }
01247 }
01248 }
01249
01253 private void CS_EncryptInit()
01254 {
01255 UInt32 ret = ErrorManager.DKMS_OK;
01256 CryptoCore.CCConvert converter;
01257
01258 UInt32 hSession;
01259 UInt32 hKey;
01260 CryptoCore.Smf.MECHANISM mech;
01261
01262
01263
01264 converter = new CryptoCore.CCConvert();
01265
01267
01268
01270 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01271 _smf.CurrentSession = hSession;
01272
01273 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01274
01275 ret = converter.ParseMechanismIn(out mech, config);
01276
01277
01278 if(ret != ErrorManager.DKMS_OK)
01279 {
01280 _pm.XMLTXParser_Set_Error(ret);
01281 }
01282
01283 else
01284 {
01285
01286 ret = _smf.ef.EncryptInit(mech, hKey);
01287
01288
01289 if(ret != ErrorManager.DKMS_OK)
01290 {
01291 _pm.XMLTXParser_Set_Error(ret);
01292 }
01293
01294 else
01295 {
01297
01298
01299 _pm.XMLTXParser_Set_Start("DKMS_EncryptInit", 1);
01300
01301 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01302
01303 _pm.XMLTXParser_Set_End();
01304 }
01305 }
01306 }
01307
01311 private void CS_Encrypt()
01312 {
01313 UInt32 ret = ErrorManager.DKMS_OK;
01314
01315 UInt32 hSession;
01316 string ClearData;
01317
01318 string EncryptedData;
01319
01320
01322
01323
01325
01326 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01327 _smf.CurrentSession = hSession;
01328
01329 ClearData = ((ProtocolManager.Param)config.body.param["ClearData"]).vvalue;
01330
01331
01332 ret = _smf.ef.Encrypt(ClearData, out EncryptedData);
01333
01334
01335 if(ret != ErrorManager.DKMS_OK)
01336 {
01337 _pm.XMLTXParser_Set_Error(ret);
01338 }
01339
01340 else
01341 {
01343
01344
01345 _pm.XMLTXParser_Set_Start("DKMS_Encrypt", 2);
01346
01347 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01348 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedData", ProtocolManager.PARAM_TYPE.STRING, EncryptedData);
01349
01350 _pm.XMLTXParser_Set_End();
01351 }
01352 }
01353
01357 private void CS_CompactEncrypt()
01358 {
01359 UInt32 ret = ErrorManager.DKMS_OK;
01360 CryptoCore.CCConvert converter;
01361
01362 UInt32 hSession;
01363 UInt32 hKey;
01364 CryptoCore.Smf.MECHANISM mech;
01365 string ClearData;
01366
01367 string EncryptedData;
01368
01369
01370
01371 converter = new CryptoCore.CCConvert();
01372
01374
01375
01376
01378 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01379 _smf.CurrentSession = hSession;
01380
01381 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01382
01383 ClearData = ((ProtocolManager.Param)config.body.param["ClearData"]).vvalue;
01384
01385 ret = converter.ParseMechanismIn(out mech, config);
01386
01387
01388 if (ret != ErrorManager.DKMS_OK)
01389 {
01390 _pm.XMLTXParser_Set_Error(ret);
01391 }
01392
01393 else
01394 {
01395
01396 ret = _smf.ef.CompactEncrypt(mech, hKey, ClearData, out EncryptedData);
01397
01398
01399 if (ret != ErrorManager.DKMS_OK)
01400 {
01401 _pm.XMLTXParser_Set_Error(ret);
01402 }
01403
01404 else
01405 {
01407
01408
01409 _pm.XMLTXParser_Set_Start("DKMS_CompactEncrypt", 2);
01410
01411 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01412 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedData", ProtocolManager.PARAM_TYPE.STRING, EncryptedData);
01413
01414 _pm.XMLTXParser_Set_End();
01415 }
01416 }
01417 }
01418
01423 private void CS_EncryptUpdate()
01424 {
01425 UInt32 ret = ErrorManager.DKMS_OK;
01426
01427 UInt32 hSession;
01428 string ClearPartData;
01429
01430 string EncryptedPartData;
01431
01432
01434
01435
01437
01438 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01439 _smf.CurrentSession = hSession;
01440
01441 ClearPartData = ((ProtocolManager.Param)config.body.param["ClearPartData"]).vvalue;
01442
01443
01444 ret = _smf.ef.EncryptUpdate(ClearPartData, out EncryptedPartData);
01445
01446
01447 if(ret != ErrorManager.DKMS_OK)
01448 {
01449 _pm.XMLTXParser_Set_Error(ret);
01450 }
01451
01452 else
01453 {
01455
01456
01457 _pm.XMLTXParser_Set_Start("DKMS_EncryptUpdate", 2);
01458
01459 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01460 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, EncryptedPartData);
01461
01462 _pm.XMLTXParser_Set_End();
01463 }
01464 }
01465
01469 private void CS_EncryptFinal()
01470 {
01471 UInt32 ret = ErrorManager.DKMS_OK;
01472
01473 UInt32 hSession;
01474
01475 string LastEncryptedPartData;
01476
01477
01479
01480
01482
01483 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01484 _smf.CurrentSession = hSession;
01485
01486
01487 ret = _smf.ef.EncryptFinal(out LastEncryptedPartData);
01488
01489
01490 if(ret != ErrorManager.DKMS_OK)
01491 {
01492 _pm.XMLTXParser_Set_Error(ret);
01493 }
01494
01495 else
01496 {
01498
01499
01500 _pm.XMLTXParser_Set_Start("DKMS_EncryptFinal", 2);
01501
01502 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01503 _pm.XMLTXParser_Set_ParamAtomic(1, "LastEncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, LastEncryptedPartData);
01504
01505 _pm.XMLTXParser_Set_End();
01506 }
01507 }
01508
01512 private void CS_DecryptInit()
01513 {
01514 UInt32 ret = ErrorManager.DKMS_OK;
01515 CryptoCore.CCConvert converter;
01516
01517 UInt32 hSession;
01518 CryptoCore.Smf.MECHANISM mech;
01519 UInt32 hKey;
01520
01521
01522
01523 converter = new CryptoCore.CCConvert();
01524
01526
01527
01529
01530 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01531 _smf.CurrentSession = hSession;
01532
01533 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01534
01535 ret = converter.ParseMechanismIn(out mech, config);
01536
01537
01538 if(ret != ErrorManager.DKMS_OK)
01539 {
01540 _pm.XMLTXParser_Set_Error(ret);
01541 }
01542
01543 else
01544 {
01545
01546 ret = _smf.df.DecryptInit(mech, hKey);
01547
01548
01549 if(ret != ErrorManager.DKMS_OK)
01550 {
01551 _pm.XMLTXParser_Set_Error(ret);
01552 }
01553
01554 else
01555 {
01557
01558
01559 _pm.XMLTXParser_Set_Start("DKMS_DecryptInit", 1);
01560
01561 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01562
01563 _pm.XMLTXParser_Set_End();
01564 }
01565 }
01566 }
01567
01571 private void CS_Decrypt()
01572 {
01573 UInt32 ret = ErrorManager.DKMS_OK;
01574
01575 UInt32 hSession;
01576 string EncryptedData;
01577
01578 string ClearData;
01579
01580
01582
01583
01585
01586 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01587 _smf.CurrentSession = hSession;
01588
01589 EncryptedData = ((ProtocolManager.Param)config.body.param["EncryptedData"]).vvalue;
01590
01591
01592 ret = _smf.df.Decrypt(EncryptedData, out ClearData);
01593
01594
01595 if(ret != ErrorManager.DKMS_OK)
01596 {
01597 _pm.XMLTXParser_Set_Error(ret);
01598 }
01599
01600 else
01601 {
01603
01604
01605 _pm.XMLTXParser_Set_Start("DKMS_Decrypt", 2);
01606
01607 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01608 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearData", ProtocolManager.PARAM_TYPE.STRING, ClearData);
01609
01610 _pm.XMLTXParser_Set_End();
01611 }
01612 }
01613
01617 private void CS_CompactDecrypt()
01618 {
01619 UInt32 ret = ErrorManager.DKMS_OK;
01620 CryptoCore.CCConvert converter;
01621
01622 UInt32 hSession;
01623 CryptoCore.Smf.MECHANISM mech;
01624 UInt32 hKey;
01625 string EncryptedData;
01626
01627 string ClearData;
01628
01629
01630
01631 converter = new CryptoCore.CCConvert();
01632
01634
01635
01636
01638
01639 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01640 _smf.CurrentSession = hSession;
01641
01642 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
01643
01644 EncryptedData = ((ProtocolManager.Param)config.body.param["EncryptedData"]).vvalue;
01645
01646 ret = converter.ParseMechanismIn(out mech, config);
01647
01648
01649 if (ret != ErrorManager.DKMS_OK)
01650 {
01651 _pm.XMLTXParser_Set_Error(ret);
01652 }
01653
01654 else
01655 {
01656
01657 ret = _smf.df.CompactDecrypt(mech, hKey, EncryptedData, out ClearData);
01658
01659
01660 if (ret != ErrorManager.DKMS_OK)
01661 {
01662 _pm.XMLTXParser_Set_Error(ret);
01663 }
01664
01665 else
01666 {
01668
01669
01670 _pm.XMLTXParser_Set_Start("DKMS_CompactDecrypt", 2);
01671
01672 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01673 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearData", ProtocolManager.PARAM_TYPE.STRING, ClearData);
01674
01675 _pm.XMLTXParser_Set_End();
01676 }
01677 }
01678 }
01679
01684 private void CS_DecryptUpdate()
01685 {
01686 UInt32 ret = ErrorManager.DKMS_OK;
01687
01688 UInt32 hSession;
01689 string EncryptedPartData;
01690
01691 string ClearPartData;
01692
01693
01695
01696
01698
01699 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01700 _smf.CurrentSession = hSession;
01701
01702 EncryptedPartData = ((ProtocolManager.Param)config.body.param["EncryptedPartData"]).vvalue;
01703
01704
01705 ret = _smf.df.DecryptUpdate(EncryptedPartData, out ClearPartData);
01706
01707
01708 if(ret != ErrorManager.DKMS_OK)
01709 {
01710 _pm.XMLTXParser_Set_Error(ret);
01711 }
01712
01713 else
01714 {
01716
01717
01718 _pm.XMLTXParser_Set_Start("DKMS_DecryptUpdate", 2);
01719
01720 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01721 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearPartData", ProtocolManager.PARAM_TYPE.STRING, ClearPartData);
01722
01723 _pm.XMLTXParser_Set_End();
01724 }
01725 }
01726
01730 private void CS_DecryptFinal()
01731 {
01732 UInt32 ret = ErrorManager.DKMS_OK;
01733
01734 UInt32 hSession;
01735
01736 string LastDecryptedPartData;
01737
01738
01740
01741
01743
01744 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01745 _smf.CurrentSession = hSession;
01746
01747
01748 ret = _smf.df.DecryptFinal(out LastDecryptedPartData);
01749
01750
01751 if(ret != ErrorManager.DKMS_OK)
01752 {
01753 _pm.XMLTXParser_Set_Error(ret);
01754 }
01755
01756 else
01757 {
01759
01760
01761 _pm.XMLTXParser_Set_Start("DKMS_DecryptFinal", 2);
01762
01763 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01764 _pm.XMLTXParser_Set_ParamAtomic(1, "LastDecryptedPartData", ProtocolManager.PARAM_TYPE.STRING, LastDecryptedPartData);
01765
01766 _pm.XMLTXParser_Set_End();
01767 }
01768 }
01769
01773 private void CS_GetInfo()
01774 {
01775 UInt32 ret = ErrorManager.DKMS_OK;
01776
01777 CryptoCore.CK_INFO pInfo;
01778
01779
01780
01781 ret = _cc.GetInfo(out pInfo);
01782
01783
01784 if(ret != ErrorManager.DKMS_OK)
01785 {
01786 _pm.XMLTXParser_Set_Error(ret);
01787 }
01788
01789 else
01790 {
01792
01793
01794 _pm.XMLTXParser_Set_Start("DKMS_GetInfo", 2);
01795
01796 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01797 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
01798 _pm.XMLTXParser_Set_StartParamStruct(0, "pInfo.cryptokiVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01799 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.cryptokiVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.cryptokiVersion.major.ToString());
01800 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.cryptokiVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.cryptokiVersion.minor.ToString());
01801 _pm.XMLTXParser_Set_EndParamStruct();
01802 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.manufacturerID", ProtocolManager.PARAM_TYPE.STRING, pInfo.manufacturerID);
01803 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
01804 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.libraryDescription", ProtocolManager.PARAM_TYPE.STRING, pInfo.libraryDescription);
01805 _pm.XMLTXParser_Set_StartParamStruct(4, "pInfo.libraryVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01806 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.libraryVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.libraryVersion.major.ToString());
01807 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.libraryVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.libraryVersion.minor.ToString());
01808 _pm.XMLTXParser_Set_EndParamStruct();
01809 _pm.XMLTXParser_Set_EndParamStruct();
01810
01811 _pm.XMLTXParser_Set_End();
01812 }
01813 }
01814
01818 private void CS_GetTokenInfo()
01819 {
01820 UInt32 ret = ErrorManager.DKMS_OK;
01821
01822 UInt32 slotID;
01823
01824 CryptoCore.Stmf.CK_TOKEN_INFO pInfo;
01825
01826
01828
01829
01831 slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
01832
01833
01834 ret = _stmf.GetTokenInfo(slotID, out pInfo);
01835
01836
01837 if(ret != ErrorManager.DKMS_OK)
01838 {
01839 _pm.XMLTXParser_Set_Error(ret);
01840 }
01841
01842 else
01843 {
01845
01846
01847 _pm.XMLTXParser_Set_Start("DKMS_GetTokenInfo", 2);
01848
01849 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01850 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
01851 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.label", ProtocolManager.PARAM_TYPE.STRING, pInfo.label);
01852 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.manufacturerID", ProtocolManager.PARAM_TYPE.STRING, pInfo.manufacturerID);
01853 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.model", ProtocolManager.PARAM_TYPE.STRING, pInfo.model);
01854 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.serialNumber", ProtocolManager.PARAM_TYPE.STRING, pInfo.serialNumber);
01855 _pm.XMLTXParser_Set_ParamAtomic(4, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
01856 _pm.XMLTXParser_Set_ParamAtomic(5, "pInfo.ulMaxSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxSessionCount.ToString());
01857 _pm.XMLTXParser_Set_ParamAtomic(6, "pInfo.ulSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulSessionCount.ToString());
01858 _pm.XMLTXParser_Set_ParamAtomic(7, "pInfo.ulMaxRwSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxRwSessionCount.ToString());
01859 _pm.XMLTXParser_Set_ParamAtomic(8, "pInfo.ulRwSessionCount", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulRwSessionCount.ToString());
01860 _pm.XMLTXParser_Set_ParamAtomic(9, "pInfo.ulMaxPinLen", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxPinLen.ToString());
01861 _pm.XMLTXParser_Set_ParamAtomic(10, "pInfo.ulMinPinLen", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMinPinLen.ToString());
01862 _pm.XMLTXParser_Set_ParamAtomic(11, "pInfo.ulTotalPublicMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulTotalPublicMemory.ToString());
01863 _pm.XMLTXParser_Set_ParamAtomic(12, "pInfo.ulFreePublicMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulFreePublicMemory.ToString());
01864 _pm.XMLTXParser_Set_ParamAtomic(13, "pInfo.ulTotalPrivateMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulTotalPrivateMemory.ToString());
01865 _pm.XMLTXParser_Set_ParamAtomic(14, "pInfo.ulFreePrivateMemory", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulFreePrivateMemory.ToString());
01866 _pm.XMLTXParser_Set_StartParamStruct(15, "pInfo.hardwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01867 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.hardwareVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.hardwareVersion.major.ToString());
01868 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.hardwareVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.hardwareVersion.minor.ToString());
01869 _pm.XMLTXParser_Set_EndParamStruct();
01870 _pm.XMLTXParser_Set_StartParamStruct(16, "pInfo.firmwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
01871 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.firmwareVersion.major", ProtocolManager.PARAM_TYPE.BYTE, pInfo.firmwareVersion.major.ToString());
01872 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.firmwareVersion.minor", ProtocolManager.PARAM_TYPE.BYTE, pInfo.firmwareVersion.minor.ToString());
01873 _pm.XMLTXParser_Set_EndParamStruct();
01874 _pm.XMLTXParser_Set_ParamAtomic(17, "pInfo.utcTime", ProtocolManager.PARAM_TYPE.STRING, pInfo.utcTime);
01875 _pm.XMLTXParser_Set_EndParamStruct();
01876
01877 _pm.XMLTXParser_Set_End();
01878 }
01879 }
01880
01885 private void CS_SeedRandom()
01886 {
01887 UInt32 ret = ErrorManager.DKMS_OK;
01888
01889 UInt32 hSession;
01890 string Seed;
01891
01892
01894
01895
01897
01898 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01899 _smf.CurrentSession = hSession;
01900
01901 Seed = ((ProtocolManager.Param)config.body.param["Seed"]).vvalue;
01902
01903
01904 ret = _smf.rngf.SeedRandom(Seed);
01905
01906
01907 if (ret != ErrorManager.DKMS_OK)
01908 {
01909 _pm.XMLTXParser_Set_Error(ret);
01910 }
01911
01912 else
01913 {
01915
01916
01917 _pm.XMLTXParser_Set_Start("DKMS_SeedRandom", 1);
01918
01919 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01920
01921 _pm.XMLTXParser_Set_End();
01922 }
01923 }
01924
01928 private void CS_GenerateRandom()
01929 {
01930 UInt32 ret = ErrorManager.DKMS_OK;
01931
01932 UInt32 hSession;
01933 UInt32 ulRandomLen;
01934
01935 string RandomData;
01936
01937
01939
01940
01942
01943 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01944 _smf.CurrentSession = hSession;
01945
01946 ulRandomLen = UInt32.Parse(((ProtocolManager.Param)config.body.param["ulRandomLen"]).vvalue);
01947
01948
01949 ret = _smf.rngf.GenerateRandom(out RandomData, ulRandomLen);
01950
01951
01952 if (ret != ErrorManager.DKMS_OK)
01953 {
01954 _pm.XMLTXParser_Set_Error(ret);
01955 }
01956
01957 else
01958 {
01960
01961
01962 _pm.XMLTXParser_Set_Start("DKMS_GenerateRandom", 2);
01963
01964 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
01965 _pm.XMLTXParser_Set_ParamAtomic(1, "RandomData", ProtocolManager.PARAM_TYPE.STRING, RandomData);
01966
01967 _pm.XMLTXParser_Set_End();
01968 }
01969 }
01970
01975 private void CS_CompactGenerateRandom()
01976 {
01977 UInt32 ret = ErrorManager.DKMS_OK;
01978
01979 UInt32 hSession;
01980 string Seed;
01981 UInt32 ulRandomLen;
01982
01983 string RandomData;
01984
01985
01987
01988
01989
01991
01992 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
01993 _smf.CurrentSession = hSession;
01994
01995 ulRandomLen = UInt32.Parse(((ProtocolManager.Param)config.body.param["ulRandomLen"]).vvalue);
01996
01997 Seed = ((ProtocolManager.Param)config.body.param["Seed"]).vvalue;
01998
01999
02000 ret = _smf.rngf.CompactGenerateRandom(Seed, out RandomData, ulRandomLen);
02001
02002
02003 if (ret != ErrorManager.DKMS_OK)
02004 {
02005 _pm.XMLTXParser_Set_Error(ret);
02006 }
02007
02008 else
02009 {
02011
02012
02013 _pm.XMLTXParser_Set_Start("DKMS_CompactGenerateRandom", 2);
02014
02015 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02016 _pm.XMLTXParser_Set_ParamAtomic(1, "RandomData", ProtocolManager.PARAM_TYPE.STRING, RandomData);
02017
02018 _pm.XMLTXParser_Set_End();
02019 }
02020 }
02021
02025 private void CS_GenerateKey()
02026 {
02027 UInt32 ret = ErrorManager.DKMS_OK;
02028 CryptoCore.CCConvert converter;
02029 UInt32 ulCount;
02030
02031 UInt32 hSession;
02032 CryptoCore.ATTRIBUTE_VALUE templ;
02033 CryptoCore.Smf.MECHANISM mech;
02034
02035 UInt32 phKey;
02036
02037
02038
02039 converter = new CryptoCore.CCConvert();
02040
02042
02043
02044
02046
02047 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02048 _smf.CurrentSession = hSession;
02049
02050 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
02051 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
02052
02053
02054 if(ret != ErrorManager.DKMS_OK)
02055 {
02056 _pm.XMLTXParser_Set_Error(ret);
02057 }
02058
02059 else
02060 {
02061
02062 ret = converter.ParseMechanismIn(out mech, config);
02063
02064
02065 if (ret != ErrorManager.DKMS_OK)
02066 {
02067 _pm.XMLTXParser_Set_Error(ret);
02068 }
02069
02070 else
02071 {
02072
02073 ret = _smf.kmf.GenerateKey(templ, mech, out phKey);
02074
02075
02076 if (ret != ErrorManager.DKMS_OK)
02077 {
02078 _pm.XMLTXParser_Set_Error(ret);
02079 }
02080
02081 else
02082 {
02084
02085
02086 _pm.XMLTXParser_Set_Start("DKMS_GenerateKey", 2);
02087
02088 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02089 _pm.XMLTXParser_Set_ParamAtomic(1, "phKey", ProtocolManager.PARAM_TYPE.UINT32, phKey.ToString());
02090
02091 _pm.XMLTXParser_Set_End();
02092 }
02093 }
02094 }
02095 }
02096
02100 private void CS_DestroyObject()
02101 {
02102 UInt32 ret = ErrorManager.DKMS_OK;
02103
02104 UInt32 hSession;
02105 UInt32 hObject;
02106
02107
02109
02110
02112
02113 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02114 _smf.CurrentSession = hSession;
02115
02116 hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
02117
02118
02119 ret = _smf.omf.DestroyObject(hObject);
02120
02121
02122 if (ret != ErrorManager.DKMS_OK)
02123 {
02124 _pm.XMLTXParser_Set_Error(ret);
02125 }
02126
02127 else
02128 {
02130
02131
02132 _pm.XMLTXParser_Set_Start("DKMS_DestroyObject", 1);
02133
02134 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02135
02136 _pm.XMLTXParser_Set_End();
02137 }
02138 }
02139
02143 private void CS_GetMechanismList()
02144 {
02145 UInt32 ret = ErrorManager.DKMS_OK;
02146
02147 UInt32 slotID;
02148
02149 Int32[] MechanismList;
02150
02151
02153
02154
02156
02157 slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
02158
02159
02160 ret = _stmf.GetMechanismList(slotID, out MechanismList);
02161
02162
02163 if (ret != ErrorManager.DKMS_OK)
02164 {
02165 _pm.XMLTXParser_Set_Error(ret);
02166 }
02167
02168 else
02169 {
02171
02172
02173 _pm.XMLTXParser_Set_Start("DKMS_GetMechanismList", 2);
02174
02175 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02176 _pm.XMLTXParser_Set_StartParamArray(1, "MechanismList", ProtocolManager.PARAM_TYPE.INT32, (UInt32)MechanismList.Length, 0);
02177 for (int i = 0; i < MechanismList.Length; i++)
02178 _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "MechanismList[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.INT32, MechanismList[i].ToString());
02179 _pm.XMLTXParser_Set_EndParamArray();
02180
02181 _pm.XMLTXParser_Set_End();
02182 }
02183 }
02184
02188 private void CS_GetAttributeValue()
02189 {
02190 UInt32 ret = ErrorManager.DKMS_OK;
02191 CryptoCore.CCConvert converter;
02192 UInt32 ulCount;
02193
02194 UInt32 hSession;
02195 UInt32 hObject;
02196 CryptoCore.CK_ATTRIBUTE_TYPE[] atype;
02197
02198 CryptoCore.ATTRIBUTE_VALUE templ;
02199
02200
02201
02202 converter = new CryptoCore.CCConvert();
02203
02205
02206
02207
02209
02210 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02211 _smf.CurrentSession = hSession;
02212
02213 ulCount = ((ProtocolManager.Param)config.body.param["atype"]).XDim;
02214 atype = new CryptoCore.CK_ATTRIBUTE_TYPE[ulCount];
02215 for (int i = 0; i < ulCount; i++)
02216 atype[i] = (CryptoCore.CK_ATTRIBUTE_TYPE)int.Parse(((ProtocolManager.Param)config.body.param["atype[" + i.ToString() + "]"]).vvalue);
02217
02218 hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
02219
02220
02221 ret = _smf.omf.GetAttributeValue(atype, out templ, hObject);
02222
02223
02224 if (ret != ErrorManager.DKMS_OK)
02225 {
02226 _pm.XMLTXParser_Set_Error(ret);
02227 }
02228
02229 else
02230 {
02232
02233
02234 _pm.XMLTXParser_Set_Start("DKMS_GetAttributeValue", 2);
02235
02236 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02237
02238 ret = converter.ParseAttributeOut(templ, ref _pm, converter.AttributeCount(templ), 1, "templ");
02239 if (ret != ErrorManager.DKMS_OK)
02240 throw new Exception();
02241
02242 _pm.XMLTXParser_Set_End();
02243 }
02244 }
02245
02249 private void CS_DigestInit()
02250 {
02251 UInt32 ret = ErrorManager.DKMS_OK;
02252 CryptoCore.CCConvert converter;
02253
02254 UInt32 hSession;
02255 CryptoCore.Smf.MECHANISM mech;
02256
02257
02258
02259 converter = new CryptoCore.CCConvert();
02260
02262
02263
02265 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02266 _smf.CurrentSession = hSession;
02267
02268 ret = converter.ParseMechanismIn(out mech, config);
02269
02270
02271 if(ret != ErrorManager.DKMS_OK)
02272 {
02273 _pm.XMLTXParser_Set_Error(ret);
02274 }
02275
02276 else
02277 {
02278
02279 ret = _smf.mdf.DigestInit(mech);
02280
02281
02282 if(ret != ErrorManager.DKMS_OK)
02283 {
02284 _pm.XMLTXParser_Set_Error(ret);
02285 }
02286
02287 else
02288 {
02290
02291
02292 _pm.XMLTXParser_Set_Start("DKMS_DigestInit", 1);
02293
02294 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02295
02296 _pm.XMLTXParser_Set_End();
02297 }
02298 }
02299 }
02300
02304 private void CS_Digest()
02305 {
02306 UInt32 ret = ErrorManager.DKMS_OK;
02307
02308 UInt32 hSession;
02309 string Data;
02310
02311 string Digest;
02312
02313
02315
02316
02318
02319 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02320 _smf.CurrentSession = hSession;
02321
02322 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02323
02324
02325 ret = _smf.mdf.Digest(Data, out Digest);
02326
02327
02328 if(ret != ErrorManager.DKMS_OK)
02329 {
02330 _pm.XMLTXParser_Set_Error(ret);
02331 }
02332
02333 else
02334 {
02336
02337
02338 _pm.XMLTXParser_Set_Start("DKMS_Digest", 2);
02339
02340 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02341 _pm.XMLTXParser_Set_ParamAtomic(1, "Digest", ProtocolManager.PARAM_TYPE.STRING, Digest);
02342
02343 _pm.XMLTXParser_Set_End();
02344 }
02345 }
02346
02350 private void CS_CompactDigest()
02351 {
02352 UInt32 ret = ErrorManager.DKMS_OK;
02353 CryptoCore.CCConvert converter;
02354
02355 UInt32 hSession;
02356 CryptoCore.Smf.MECHANISM mech;
02357 string Data;
02358
02359 string Digest;
02360
02361
02362
02363 converter = new CryptoCore.CCConvert();
02364
02366
02367
02368
02370 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02371 _smf.CurrentSession = hSession;
02372
02373 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02374
02375 ret = converter.ParseMechanismIn(out mech, config);
02376
02377
02378 if (ret != ErrorManager.DKMS_OK)
02379 {
02380 _pm.XMLTXParser_Set_Error(ret);
02381 }
02382
02383 else
02384 {
02385
02386 ret = _smf.mdf.CompactDigest(mech, Data, out Digest);
02387
02388
02389 if (ret != ErrorManager.DKMS_OK)
02390 {
02391 _pm.XMLTXParser_Set_Error(ret);
02392 }
02393
02394 else
02395 {
02397
02398
02399 _pm.XMLTXParser_Set_Start("DKMS_CompactDigest", 2);
02400
02401 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02402 _pm.XMLTXParser_Set_ParamAtomic(1, "Digest", ProtocolManager.PARAM_TYPE.STRING, Digest);
02403
02404 _pm.XMLTXParser_Set_End();
02405 }
02406 }
02407 }
02408
02413 private void CS_DigestUpdate()
02414 {
02415 UInt32 ret = ErrorManager.DKMS_OK;
02416
02417 UInt32 hSession;
02418 string PartData;
02419
02420
02422
02423
02425
02426 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02427 _smf.CurrentSession = hSession;
02428
02429 PartData = ((ProtocolManager.Param)config.body.param["PartData"]).vvalue;
02430
02431
02432 ret = _smf.mdf.DigestUpdate(PartData);
02433
02434
02435 if(ret != ErrorManager.DKMS_OK)
02436 {
02437 _pm.XMLTXParser_Set_Error(ret);
02438 }
02439
02440 else
02441 {
02443
02444
02445 _pm.XMLTXParser_Set_Start("DKMS_DigestUpdate", 1);
02446
02447 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02448
02449 _pm.XMLTXParser_Set_End();
02450 }
02451 }
02452
02457 private void CS_DigestKey()
02458 {
02459 UInt32 ret = ErrorManager.DKMS_OK;
02460
02461 UInt32 hSession;
02462 UInt32 hKey;
02463
02464
02466
02467
02469 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02470 _smf.CurrentSession = hSession;
02471
02472 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02473
02474
02475 ret = _smf.mdf.DigestKey(hKey);
02476
02477
02478 if(ret != ErrorManager.DKMS_OK)
02479 {
02480 _pm.XMLTXParser_Set_Error(ret);
02481 }
02482
02483 else
02484 {
02486
02487
02488 _pm.XMLTXParser_Set_Start("DKMS_DigestKey", 1);
02489
02490 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02491
02492 _pm.XMLTXParser_Set_End();
02493 }
02494 }
02495
02500 private void CS_DigestFinal()
02501 {
02502 UInt32 ret = ErrorManager.DKMS_OK;
02503
02504 UInt32 hSession;
02505
02506 string Digest;
02507
02508
02510
02511
02513
02514 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02515 _smf.CurrentSession = hSession;
02516
02517
02518 ret = _smf.mdf.DigestFinal(out Digest);
02519
02520
02521 if(ret != ErrorManager.DKMS_OK)
02522 {
02523 _pm.XMLTXParser_Set_Error(ret);
02524 }
02525
02526 else
02527 {
02529
02530
02531 _pm.XMLTXParser_Set_Start("DKMS_DigestFinal", 2);
02532
02533 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02534 _pm.XMLTXParser_Set_ParamAtomic(1, "Digest", ProtocolManager.PARAM_TYPE.STRING, Digest);
02535
02536 _pm.XMLTXParser_Set_End();
02537 }
02538 }
02539
02544 private void CS_SignInit()
02545 {
02546 UInt32 ret = ErrorManager.DKMS_OK;
02547 CryptoCore.CCConvert converter;
02548
02549 UInt32 hSession;
02550 CryptoCore.Smf.MECHANISM mech;
02551 UInt32 hKey;
02552
02553
02554
02555 converter = new CryptoCore.CCConvert();
02556
02558
02559
02561 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02562 _smf.CurrentSession = hSession;
02563
02564 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02565
02566 ret = converter.ParseMechanismIn(out mech, config);
02567
02568
02569 if(ret != ErrorManager.DKMS_OK)
02570 {
02571 _pm.XMLTXParser_Set_Error(ret);
02572 }
02573
02574 else
02575 {
02576
02577 ret = _smf.smacf.SignInit(mech, hKey);
02578
02579
02580 if(ret != ErrorManager.DKMS_OK)
02581 {
02582 _pm.XMLTXParser_Set_Error(ret);
02583 }
02584
02585 else
02586 {
02588
02589
02590 _pm.XMLTXParser_Set_Start("DKMS_SignInit", 1);
02591
02592 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02593
02594 _pm.XMLTXParser_Set_End();
02595 }
02596 }
02597 }
02598
02603 private void CS_Sign()
02604 {
02605 UInt32 ret = ErrorManager.DKMS_OK;
02606
02607 UInt32 hSession;
02608 string Data;
02609
02610 string Signature;
02611
02612
02614
02615
02617
02618 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02619 _smf.CurrentSession = hSession;
02620
02621 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02622
02623
02624 ret = _smf.smacf.Sign(Data, out Signature);
02625
02626
02627 if(ret != ErrorManager.DKMS_OK)
02628 {
02629 _pm.XMLTXParser_Set_Error(ret);
02630 }
02631
02632 else
02633 {
02635
02636
02637 _pm.XMLTXParser_Set_Start("DKMS_Sign", 2);
02638
02639 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02640 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02641
02642 _pm.XMLTXParser_Set_End();
02643 }
02644 }
02645
02650 private void CS_CompactSign()
02651 {
02652 UInt32 ret = ErrorManager.DKMS_OK;
02653 CryptoCore.CCConvert converter;
02654
02655 UInt32 hSession;
02656 CryptoCore.Smf.MECHANISM mech;
02657 UInt32 hKey;
02658 string Data;
02659
02660 string Signature;
02661
02662
02663
02664 converter = new CryptoCore.CCConvert();
02665
02667
02668
02669
02671 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02672 _smf.CurrentSession = hSession;
02673
02674 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02675
02676 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02677
02678 ret = converter.ParseMechanismIn(out mech, config);
02679
02680
02681 if (ret != ErrorManager.DKMS_OK)
02682 {
02683 _pm.XMLTXParser_Set_Error(ret);
02684 }
02685
02686 else
02687 {
02688
02689 ret = _smf.smacf.CompactSign(mech, hKey, Data, out Signature);
02690
02691
02692 if (ret != ErrorManager.DKMS_OK)
02693 {
02694 _pm.XMLTXParser_Set_Error(ret);
02695 }
02696
02697 else
02698 {
02700
02701
02702 _pm.XMLTXParser_Set_Start("DKMS_CompactSign", 2);
02703
02704 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02705 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02706
02707 _pm.XMLTXParser_Set_End();
02708 }
02709 }
02710 }
02711
02716 private void CS_SignUpdate()
02717 {
02718 UInt32 ret = ErrorManager.DKMS_OK;
02719
02720 UInt32 hSession;
02721 string PartData;
02722
02723
02725
02726
02728
02729 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02730 _smf.CurrentSession = hSession;
02731
02732 PartData = ((ProtocolManager.Param)config.body.param["PartData"]).vvalue;
02733
02734
02735 ret = _smf.smacf.SignUpdate(PartData);
02736
02737
02738 if(ret != ErrorManager.DKMS_OK)
02739 {
02740 _pm.XMLTXParser_Set_Error(ret);
02741 }
02742
02743 else
02744 {
02746
02747
02748 _pm.XMLTXParser_Set_Start("DKMS_SignUpdate", 1);
02749
02750 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02751
02752 _pm.XMLTXParser_Set_End();
02753 }
02754 }
02755
02760 private void CS_SignFinal()
02761 {
02762 UInt32 ret = ErrorManager.DKMS_OK;
02763
02764 UInt32 hSession;
02765
02766 string Signature;
02767
02768
02770
02771
02773
02774 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02775 _smf.CurrentSession = hSession;
02776
02777
02778 ret = _smf.smacf.SignFinal(out Signature);
02779
02780
02781 if(ret != ErrorManager.DKMS_OK)
02782 {
02783 _pm.XMLTXParser_Set_Error(ret);
02784 }
02785
02786 else
02787 {
02789
02790
02791 _pm.XMLTXParser_Set_Start("DKMS_SignFinal", 2);
02792
02793 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02794 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02795
02796 _pm.XMLTXParser_Set_End();
02797 }
02798 }
02799
02804 private void CS_SignRecoverInit()
02805 {
02806 UInt32 ret = ErrorManager.DKMS_OK;
02807 CryptoCore.CCConvert converter;
02808
02809 UInt32 hSession;
02810 CryptoCore.Smf.MECHANISM mech;
02811 UInt32 hKey;
02812
02813
02814
02815 converter = new CryptoCore.CCConvert();
02816
02818
02819
02821 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02822 _smf.CurrentSession = hSession;
02823
02824 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02825
02826 ret = converter.ParseMechanismIn(out mech, config);
02827
02828
02829 if(ret != ErrorManager.DKMS_OK)
02830 {
02831 _pm.XMLTXParser_Set_Error(ret);
02832 }
02833
02834 else
02835 {
02836
02837 ret = _smf.smacf.SignRecoverInit(mech, hKey);
02838
02839
02840 if(ret != ErrorManager.DKMS_OK)
02841 {
02842 _pm.XMLTXParser_Set_Error(ret);
02843 }
02844
02845 else
02846 {
02848
02849
02850 _pm.XMLTXParser_Set_Start("DKMS_SignRecoverInit", 1);
02851
02852 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02853
02854 _pm.XMLTXParser_Set_End();
02855 }
02856 }
02857 }
02858
02863 private void CS_SignRecover()
02864 {
02865 UInt32 ret = ErrorManager.DKMS_OK;
02866
02867 UInt32 hSession;
02868 string Data;
02869
02870 string Signature;
02871
02872
02874
02875
02877
02878 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02879 _smf.CurrentSession = hSession;
02880
02881 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02882
02883
02884 ret = _smf.smacf.SignRecover(Data, out Signature);
02885
02886
02887 if(ret != ErrorManager.DKMS_OK)
02888 {
02889 _pm.XMLTXParser_Set_Error(ret);
02890 }
02891
02892 else
02893 {
02895
02896
02897 _pm.XMLTXParser_Set_Start("DKMS_SignRecover", 2);
02898
02899 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02900 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02901
02902 _pm.XMLTXParser_Set_End();
02903 }
02904 }
02905
02910 private void CS_CompactSignRecover()
02911 {
02912 UInt32 ret = ErrorManager.DKMS_OK;
02913 CryptoCore.CCConvert converter;
02914
02915 UInt32 hSession;
02916 CryptoCore.Smf.MECHANISM mech;
02917 UInt32 hKey;
02918 string Data;
02919
02920 string Signature;
02921
02922
02923
02924 converter = new CryptoCore.CCConvert();
02925
02927
02928
02929
02931 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02932 _smf.CurrentSession = hSession;
02933
02934 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
02935
02936 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02937
02938 ret = converter.ParseMechanismIn(out mech, config);
02939
02940
02941 if (ret != ErrorManager.DKMS_OK)
02942 {
02943 _pm.XMLTXParser_Set_Error(ret);
02944 }
02945
02946 else
02947 {
02948
02949 ret = _smf.smacf.CompactSignRecover(mech, hKey, Data, out Signature);
02950
02951
02952 if (ret != ErrorManager.DKMS_OK)
02953 {
02954 _pm.XMLTXParser_Set_Error(ret);
02955 }
02956
02957 else
02958 {
02960
02961
02962 _pm.XMLTXParser_Set_Start("DKMS_CompactSignRecover", 2);
02963
02964 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
02965 _pm.XMLTXParser_Set_ParamAtomic(1, "Signature", ProtocolManager.PARAM_TYPE.STRING, Signature);
02966
02967 _pm.XMLTXParser_Set_End();
02968 }
02969 }
02970 }
02971
02976 private void CS_VerifyInit()
02977 {
02978 UInt32 ret = ErrorManager.DKMS_OK;
02979 CryptoCore.CCConvert converter;
02980
02981 UInt32 hSession;
02982 CryptoCore.Smf.MECHANISM mech;
02983 UInt32 hKey;
02984
02985
02986
02987 converter = new CryptoCore.CCConvert();
02988
02990
02991
02993 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
02994 _smf.CurrentSession = hSession;
02995
02996 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
02997
02998 ret = converter.ParseMechanismIn(out mech, config);
02999
03000
03001 if(ret != ErrorManager.DKMS_OK)
03002 {
03003 _pm.XMLTXParser_Set_Error(ret);
03004 }
03005
03006 else
03007 {
03008
03009 ret = _smf.fvsm.VerifyInit(mech, hKey);
03010
03011
03012 if(ret != ErrorManager.DKMS_OK)
03013 {
03014 _pm.XMLTXParser_Set_Error(ret);
03015 }
03016
03017 else
03018 {
03020
03021
03022 _pm.XMLTXParser_Set_Start("DKMS_VerifyInit", 1);
03023
03024 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03025
03026 _pm.XMLTXParser_Set_End();
03027 }
03028 }
03029 }
03030
03035 private void CS_Verify()
03036 {
03037 UInt32 ret = ErrorManager.DKMS_OK;
03038
03039 UInt32 hSession;
03040 string Data;
03041 string Signature;
03042
03043
03045
03046
03048
03049 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03050 _smf.CurrentSession = hSession;
03051
03052 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
03053
03054 Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03055
03056
03057 ret = _smf.fvsm.Verify(Data, Signature);
03058
03059
03060 if(ret != ErrorManager.DKMS_OK)
03061 {
03062 _pm.XMLTXParser_Set_Error(ret);
03063 }
03064
03065 else
03066 {
03068
03069
03070 _pm.XMLTXParser_Set_Start("DKMS_Verify", 1);
03071
03072 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03073
03074 _pm.XMLTXParser_Set_End();
03075 }
03076 }
03077
03082 private void CS_CompactVerify()
03083 {
03084 UInt32 ret = ErrorManager.DKMS_OK;
03085 CryptoCore.CCConvert converter;
03086
03087 UInt32 hSession;
03088 CryptoCore.Smf.MECHANISM mech;
03089 UInt32 hKey;
03090 string Data;
03091 string Signature;
03092
03093
03094
03095 converter = new CryptoCore.CCConvert();
03096
03098
03099
03100
03102 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03103 _smf.CurrentSession = hSession;
03104
03105 Data = ((ProtocolManager.Param)config.body.param["Data"]).vvalue;
03106
03107 Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03108
03109 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03110
03111 ret = converter.ParseMechanismIn(out mech, config);
03112
03113
03114 if (ret != ErrorManager.DKMS_OK)
03115 {
03116 _pm.XMLTXParser_Set_Error(ret);
03117 }
03118
03119 else
03120 {
03121
03122 ret = _smf.fvsm.CompactVerify(mech, hKey, Data, Signature);
03123
03124
03125 if (ret != ErrorManager.DKMS_OK)
03126 {
03127 _pm.XMLTXParser_Set_Error(ret);
03128 }
03129
03130 else
03131 {
03133
03134
03135 _pm.XMLTXParser_Set_Start("DKMS_CompactVerify", 1);
03136
03137 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03138
03139 _pm.XMLTXParser_Set_End();
03140 }
03141 }
03142 }
03143
03148 private void CS_VerifyUpdate()
03149 {
03150 UInt32 ret = ErrorManager.DKMS_OK;
03151
03152 UInt32 hSession;
03153 string PartData;
03154
03155
03157
03158
03160
03161 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03162 _smf.CurrentSession = hSession;
03163
03164 PartData = ((ProtocolManager.Param)config.body.param["PartData"]).vvalue;
03165
03166
03167 ret = _smf.fvsm.VerifyUpdate(PartData);
03168
03169
03170 if(ret != ErrorManager.DKMS_OK)
03171 {
03172 _pm.XMLTXParser_Set_Error(ret);
03173 }
03174
03175 else
03176 {
03178
03179
03180 _pm.XMLTXParser_Set_Start("DKMS_VerifyUpdate", 1);
03181
03182 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03183
03184 _pm.XMLTXParser_Set_End();
03185 }
03186 }
03187
03192 private void CS_VerifyFinal()
03193 {
03194 UInt32 ret = ErrorManager.DKMS_OK;
03195
03196 UInt32 hSession;
03197 string Signature;
03198
03199
03201
03202
03204
03205 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03206 _smf.CurrentSession = hSession;
03207
03208 Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03209
03210
03211 ret = _smf.fvsm.VerifyFinal(Signature);
03212
03213
03214 if(ret != ErrorManager.DKMS_OK)
03215 {
03216 _pm.XMLTXParser_Set_Error(ret);
03217 }
03218
03219 else
03220 {
03222
03223
03224 _pm.XMLTXParser_Set_Start("DKMS_VerifyFinal", 1);
03225
03226 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03227
03228 _pm.XMLTXParser_Set_End();
03229 }
03230 }
03231
03236 private void CS_VerifyRecoverInit()
03237 {
03238 UInt32 ret = ErrorManager.DKMS_OK;
03239 CryptoCore.CCConvert converter;
03240
03241 UInt32 hSession;
03242 CryptoCore.Smf.MECHANISM mech;
03243 UInt32 hKey;
03244
03245
03246
03247 converter = new CryptoCore.CCConvert();
03248
03250
03251
03253 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03254 _smf.CurrentSession = hSession;
03255
03256 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03257
03258 ret = converter.ParseMechanismIn(out mech, config);
03259
03260
03261 if(ret != ErrorManager.DKMS_OK)
03262 {
03263 _pm.XMLTXParser_Set_Error(ret);
03264 }
03265
03266 else
03267 {
03268
03269 ret = _smf.fvsm.VerifyRecoverInit(mech, hKey);
03270
03271
03272 if(ret != ErrorManager.DKMS_OK)
03273 {
03274 _pm.XMLTXParser_Set_Error(ret);
03275 }
03276
03277 else
03278 {
03280
03281
03282 _pm.XMLTXParser_Set_Start("DKMS_VerifyRecoverInit", 1);
03283
03284 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03285
03286 _pm.XMLTXParser_Set_End();
03287 }
03288 }
03289 }
03290
03295 private void CS_VerifyRecover()
03296 {
03297 UInt32 ret = ErrorManager.DKMS_OK;
03298
03299 UInt32 hSession;
03300 string Signature;
03301
03302 string Data;
03303
03304
03306
03307
03309
03310 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03311 _smf.CurrentSession = hSession;
03312
03313 Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03314
03315
03316 ret = _smf.fvsm.VerifyRecover(out Data, Signature);
03317
03318
03319 if(ret != ErrorManager.DKMS_OK)
03320 {
03321 _pm.XMLTXParser_Set_Error(ret);
03322 }
03323
03324 else
03325 {
03327
03328
03329 _pm.XMLTXParser_Set_Start("DKMS_VerifyRecover", 2);
03330
03331 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03332 _pm.XMLTXParser_Set_ParamAtomic(1, "Data", ProtocolManager.PARAM_TYPE.STRING, Data);
03333
03334 _pm.XMLTXParser_Set_End();
03335 }
03336 }
03337
03342 private void CS_CompactVerifyRecover()
03343 {
03344 UInt32 ret = ErrorManager.DKMS_OK;
03345 CryptoCore.CCConvert converter;
03346
03347 UInt32 hSession;
03348 CryptoCore.Smf.MECHANISM mech;
03349 UInt32 hKey;
03350 string Signature;
03351
03352 string Data;
03353
03354
03355
03356 converter = new CryptoCore.CCConvert();
03357
03359
03360
03361
03363 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03364 _smf.CurrentSession = hSession;
03365
03366 Signature = ((ProtocolManager.Param)config.body.param["Signature"]).vvalue;
03367
03368 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03369
03370 ret = converter.ParseMechanismIn(out mech, config);
03371
03372
03373 if (ret != ErrorManager.DKMS_OK)
03374 {
03375 _pm.XMLTXParser_Set_Error(ret);
03376 }
03377
03378 else
03379 {
03380
03381 ret = _smf.fvsm.CompactVerifyRecover(mech, hKey, out Data, Signature);
03382
03383
03384 if (ret != ErrorManager.DKMS_OK)
03385 {
03386 _pm.XMLTXParser_Set_Error(ret);
03387 }
03388
03389 else
03390 {
03392
03393
03394 _pm.XMLTXParser_Set_Start("DKMS_CompactVerifyRecover", 2);
03395
03396 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03397 _pm.XMLTXParser_Set_ParamAtomic(1, "Data", ProtocolManager.PARAM_TYPE.STRING, Data);
03398
03399 _pm.XMLTXParser_Set_End();
03400 }
03401 }
03402 }
03403
03408 private void CS_DigestEncryptUpdate()
03409 {
03410 UInt32 ret = ErrorManager.DKMS_OK;
03411
03412 UInt32 hSession;
03413 string ClearPartData;
03414
03415 string EncryptedPartData;
03416
03417
03419
03420
03422
03423 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03424 _smf.CurrentSession = hSession;
03425
03426 ClearPartData = ((ProtocolManager.Param)config.body.param["ClearPartData"]).vvalue;
03427
03428
03429 ret = _smf.dfcf.DigestEncryptUpdate(ClearPartData, out EncryptedPartData);
03430
03431
03432 if(ret != ErrorManager.DKMS_OK)
03433 {
03434 _pm.XMLTXParser_Set_Error(ret);
03435 }
03436
03437 else
03438 {
03440
03441
03442 _pm.XMLTXParser_Set_Start("DKMS_DigestEncryptUpdate", 2);
03443
03444 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03445 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, EncryptedPartData);
03446
03447 _pm.XMLTXParser_Set_End();
03448 }
03449 }
03450
03455 private void CS_DecryptDigestUpdate()
03456 {
03457 UInt32 ret = ErrorManager.DKMS_OK;
03458
03459 UInt32 hSession;
03460 string EncryptedPartData;
03461
03462 string ClearPartData;
03463
03464
03466
03467
03469
03470 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03471 _smf.CurrentSession = hSession;
03472
03473 EncryptedPartData = ((ProtocolManager.Param)config.body.param["EncryptedPartData"]).vvalue;
03474
03475
03476 ret = _smf.dfcf.DecryptDigestUpdate(EncryptedPartData, out ClearPartData);
03477
03478
03479 if(ret != ErrorManager.DKMS_OK)
03480 {
03481 _pm.XMLTXParser_Set_Error(ret);
03482 }
03483
03484 else
03485 {
03487
03488
03489 _pm.XMLTXParser_Set_Start("DKMS_DecryptDigestUpdate", 2);
03490
03491 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03492 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearPartData", ProtocolManager.PARAM_TYPE.STRING, ClearPartData);
03493
03494 _pm.XMLTXParser_Set_End();
03495 }
03496 }
03497
03502 private void CS_SignEncryptUpdate()
03503 {
03504 UInt32 ret = ErrorManager.DKMS_OK;
03505
03506 UInt32 hSession;
03507 string ClearPartData;
03508
03509 string EncryptedPartData;
03510
03511
03513
03514
03516
03517 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03518 _smf.CurrentSession = hSession;
03519
03520 ClearPartData = ((ProtocolManager.Param)config.body.param["ClearPartData"]).vvalue;
03521
03522
03523 ret = _smf.dfcf.SignEncryptUpdate(ClearPartData, out EncryptedPartData);
03524
03525
03526 if(ret != ErrorManager.DKMS_OK)
03527 {
03528 _pm.XMLTXParser_Set_Error(ret);
03529 }
03530
03531 else
03532 {
03534
03535
03536 _pm.XMLTXParser_Set_Start("DKMS_SignEncryptUpdate", 2);
03537
03538 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03539 _pm.XMLTXParser_Set_ParamAtomic(1, "EncryptedPartData", ProtocolManager.PARAM_TYPE.STRING, EncryptedPartData);
03540
03541 _pm.XMLTXParser_Set_End();
03542 }
03543 }
03544
03549 private void CS_DecryptVerifyUpdate()
03550 {
03551 UInt32 ret = ErrorManager.DKMS_OK;
03552
03553 UInt32 hSession;
03554 string EncryptedPartData;
03555
03556 string ClearPartData;
03557
03558
03560
03561
03563
03564 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03565 _smf.CurrentSession = hSession;
03566
03567 EncryptedPartData = ((ProtocolManager.Param)config.body.param["EncryptedPartData"]).vvalue;
03568
03569
03570 ret = _smf.dfcf.DecryptVerifyUpdate(EncryptedPartData, out ClearPartData);
03571
03572
03573 if(ret != ErrorManager.DKMS_OK)
03574 {
03575 _pm.XMLTXParser_Set_Error(ret);
03576 }
03577
03578 else
03579 {
03581
03582
03583 _pm.XMLTXParser_Set_Start("DKMS_DecryptVerifyUpdate", 2);
03584
03585 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03586 _pm.XMLTXParser_Set_ParamAtomic(1, "ClearPartData", ProtocolManager.PARAM_TYPE.STRING, ClearPartData);
03587
03588 _pm.XMLTXParser_Set_End();
03589 }
03590 }
03591
03596 private void CS_GenerateKeyPair()
03597 {
03598 UInt32 ret = ErrorManager.DKMS_OK;
03599 CryptoCore.CCConvert converter;
03600 UInt32 ulPublicKeyAttributeCount;
03601 UInt32 ulPrivateKeyAttributeCount;
03602
03603 UInt32 hSession;
03604 CryptoCore.ATTRIBUTE_VALUE templpb;
03605 CryptoCore.ATTRIBUTE_VALUE templpv;
03606 CryptoCore.Smf.MECHANISM mech;
03607
03608 UInt32 phpbKey;
03609 UInt32 phpvKey;
03610
03611
03612
03613 converter = new CryptoCore.CCConvert();
03614
03616
03617
03618
03620
03621 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03622 _smf.CurrentSession = hSession;
03623
03624 ulPublicKeyAttributeCount = ((ProtocolManager.Param)config.body.param["templpb"]).XDim;
03625 ret = converter.ParseAttributeIn(config, "templpb", ulPublicKeyAttributeCount, out templpb);
03626
03627
03628 if(ret != ErrorManager.DKMS_OK)
03629 {
03630 _pm.XMLTXParser_Set_Error(ret);
03631 }
03632
03633 else
03634 {
03635
03636 ulPrivateKeyAttributeCount = ((ProtocolManager.Param)config.body.param["templpv"]).XDim;
03637 ret = converter.ParseAttributeIn(config, "templpv", ulPrivateKeyAttributeCount, out templpv);
03638
03639
03640 if(ret != ErrorManager.DKMS_OK)
03641 {
03642 _pm.XMLTXParser_Set_Error(ret);
03643 }
03644
03645 else
03646 {
03647
03648 ret = converter.ParseMechanismIn(out mech, config);
03649
03650
03651 if (ret != ErrorManager.DKMS_OK)
03652 {
03653 _pm.XMLTXParser_Set_Error(ret);
03654 }
03655
03656 else
03657 {
03658
03659 ret = _smf.kmf.GenerateKeyPair(mech, templpb, templpv, out phpbKey, out phpvKey);
03660
03661
03662 if (ret != ErrorManager.DKMS_OK)
03663 {
03664 _pm.XMLTXParser_Set_Error(ret);
03665 }
03666
03667 else
03668 {
03670
03671
03672 _pm.XMLTXParser_Set_Start("DKMS_GenerateKeyPair", 3);
03673
03674 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03675 _pm.XMLTXParser_Set_ParamAtomic(1, "phpbKey", ProtocolManager.PARAM_TYPE.UINT32, phpbKey.ToString());
03676 _pm.XMLTXParser_Set_ParamAtomic(2, "phpvKey", ProtocolManager.PARAM_TYPE.UINT32, phpvKey.ToString());
03677
03678 _pm.XMLTXParser_Set_End();
03679 }
03680 }
03681 }
03682 }
03683 }
03684
03688 private void CS_WrapKey()
03689 {
03690 UInt32 ret = ErrorManager.DKMS_OK;
03691 CryptoCore.CCConvert converter;
03692
03693 UInt32 hSession;
03694 UInt32 hWrappingKey;
03695 UInt32 hKey;
03696 CryptoCore.Smf.MECHANISM mech;
03697
03698 string WrappedKey;
03699
03700
03701
03702 converter = new CryptoCore.CCConvert();
03703
03705
03706
03707
03709 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03710 _smf.CurrentSession = hSession;
03711
03712 hWrappingKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hWrappingKey"]).vvalue);
03713
03714 hKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hKey"]).vvalue);
03715
03716 ret = converter.ParseMechanismIn(out mech, config);
03717
03718
03719 if(ret != ErrorManager.DKMS_OK)
03720 {
03721 _pm.XMLTXParser_Set_Error(ret);
03722 }
03723
03724 else
03725 {
03726
03727 ret = _smf.kmf.WrapKey(mech, hWrappingKey, hKey, out WrappedKey);
03728
03729
03730 if(ret != ErrorManager.DKMS_OK)
03731 {
03732 _pm.XMLTXParser_Set_Error(ret);
03733 }
03734
03735 else
03736 {
03738
03739
03740 _pm.XMLTXParser_Set_Start("DKMS_WrapKey", 2);
03741
03742 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03743 _pm.XMLTXParser_Set_ParamAtomic(1, "WrappedKey", ProtocolManager.PARAM_TYPE.STRING, WrappedKey);
03744
03745 _pm.XMLTXParser_Set_End();
03746 }
03747 }
03748 }
03749
03754 private void CS_UnwrapKey()
03755 {
03756 UInt32 ret = ErrorManager.DKMS_OK;
03757 CryptoCore.CCConvert converter;
03758 UInt32 ulCount;
03759
03760 UInt32 hSession;
03761 UInt32 hUnwrappingKey;
03762 string WrappedKey;
03763 CryptoCore.ATTRIBUTE_VALUE templ;
03764 CryptoCore.Smf.MECHANISM mech;
03765
03766 UInt32 phKey;
03767
03768
03769
03770 converter = new CryptoCore.CCConvert();
03771
03773
03774
03775
03777
03778 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03779 _smf.CurrentSession = hSession;
03780
03781 hUnwrappingKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hUnwrappingKey"]).vvalue);
03782
03783 WrappedKey = ((ProtocolManager.Param)config.body.param["WrappedKey"]).vvalue;
03784
03785 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
03786 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
03787
03788
03789 if(ret != ErrorManager.DKMS_OK)
03790 {
03791 _pm.XMLTXParser_Set_Error(ret);
03792 }
03793
03794 else
03795 {
03796
03797 ret = converter.ParseMechanismIn(out mech, config);
03798
03799
03800 if(ret != ErrorManager.DKMS_OK)
03801 {
03802 _pm.XMLTXParser_Set_Error(ret);
03803 }
03804
03805 else
03806 {
03807
03808 ret = _smf.kmf.UnwrapKey(mech, hUnwrappingKey, WrappedKey, templ, out phKey);
03809
03810
03811 if(ret != ErrorManager.DKMS_OK)
03812 {
03813 _pm.XMLTXParser_Set_Error(ret);
03814 }
03815
03816 else
03817 {
03819
03820
03821 _pm.XMLTXParser_Set_Start("DKMS_UnwrapKey", 2);
03822
03823 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03824 _pm.XMLTXParser_Set_ParamAtomic(1, "phKey", ProtocolManager.PARAM_TYPE.UINT32, phKey.ToString());
03825
03826 _pm.XMLTXParser_Set_End();
03827 }
03828 }
03829 }
03830 }
03831
03835 private void CS_DeriveKey()
03836 {
03837 UInt32 ret = ErrorManager.DKMS_OK;
03838 CryptoCore.CCConvert converter;
03839 UInt32 ulCount;
03840
03841 UInt32 hSession;
03842 UInt32 hBaseKey;
03843 CryptoCore.ATTRIBUTE_VALUE templ;
03844 CryptoCore.Smf.MECHANISM mech;
03845
03846 UInt32 phKey;
03847
03848
03849
03850 converter = new CryptoCore.CCConvert();
03851
03853
03854
03855
03857
03858 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03859 _smf.CurrentSession = hSession;
03860
03861 hBaseKey = UInt32.Parse(((ProtocolManager.Param)config.body.param["hBaseKey"]).vvalue);
03862
03863 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
03864 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
03865
03866
03867 if(ret != ErrorManager.DKMS_OK)
03868 {
03869 _pm.XMLTXParser_Set_Error(ret);
03870 }
03871
03872 else
03873 {
03874
03875 ret = converter.ParseMechanismIn(out mech, config);
03876
03877
03878 if(ret != ErrorManager.DKMS_OK)
03879 {
03880 _pm.XMLTXParser_Set_Error(ret);
03881 }
03882
03883 else
03884 {
03885
03886 ret = _smf.kmf.DeriveKey(mech, hBaseKey, templ, out phKey);
03887
03888
03889 if(ret != ErrorManager.DKMS_OK)
03890 {
03891 _pm.XMLTXParser_Set_Error(ret);
03892 }
03893
03894 else
03895 {
03897
03898
03899 _pm.XMLTXParser_Set_Start("DKMS_DeriveKey", 2);
03900
03901 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03902 _pm.XMLTXParser_Set_ParamAtomic(1, "phKey", ProtocolManager.PARAM_TYPE.UINT32, phKey.ToString());
03903
03904 _pm.XMLTXParser_Set_End();
03905 }
03906 }
03907 }
03908 }
03909
03913 private void CS_SetAttributeValue()
03914 {
03915 UInt32 ret = ErrorManager.DKMS_OK;
03916 CryptoCore.CCConvert converter;
03917 UInt32 ulCount;
03918
03919 UInt32 hSession;
03920 UInt32 hObject;
03921 CryptoCore.ATTRIBUTE_VALUE templ;
03922
03923
03924
03925 converter = new CryptoCore.CCConvert();
03926
03928
03929
03931
03932 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03933 _smf.CurrentSession = hSession;
03934
03935 hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
03936
03937 ulCount = ((ProtocolManager.Param)config.body.param["templ"]).XDim;
03938 ret = converter.ParseAttributeIn(config, "templ", ulCount, out templ);
03939
03940
03941 if (ret != ErrorManager.DKMS_OK)
03942 {
03943 _pm.XMLTXParser_Set_Error(ret);
03944 }
03945
03946 else
03947 {
03948
03949 ret = _smf.omf.SetAttributeValue(hObject, templ);
03950
03951
03952 if (ret != ErrorManager.DKMS_OK)
03953 {
03954 _pm.XMLTXParser_Set_Error(ret);
03955 }
03956
03957 else
03958 {
03960
03961
03962 _pm.XMLTXParser_Set_Start("DKMS_SetAttributeValue", 1);
03963
03964 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
03965
03966 _pm.XMLTXParser_Set_End();
03967 }
03968 }
03969 }
03970
03974 private void CS_GetObjectSize()
03975 {
03976 UInt32 ret = ErrorManager.DKMS_OK;
03977
03978 UInt32 hSession;
03979 UInt32 hObject;
03980
03981 UInt32 pulSize;
03982
03983
03985
03986
03988
03989 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
03990 _smf.CurrentSession = hSession;
03991
03992 hObject = UInt32.Parse(((ProtocolManager.Param)config.body.param["hObject"]).vvalue);
03993
03994
03995 ret = _smf.omf.GetObjectSize(hObject, out pulSize);
03996
03997
03998 if(ret != ErrorManager.DKMS_OK)
03999 {
04000 _pm.XMLTXParser_Set_Error(ret);
04001 }
04002
04003 else
04004 {
04006
04007
04008 _pm.XMLTXParser_Set_Start("DKMS_GetObjectSize", 2);
04009
04010 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04011 _pm.XMLTXParser_Set_ParamAtomic(1, "pulSize", ProtocolManager.PARAM_TYPE.UINT32, pulSize.ToString());
04012
04013 _pm.XMLTXParser_Set_End();
04014 }
04015 }
04016
04020 private void CS_SetPIN()
04021 {
04022 UInt32 ret = ErrorManager.DKMS_OK;
04023
04024 UInt32 hSession;
04025 string OldPin;
04026 string NewPin;
04027
04028
04030
04031
04033
04034 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
04035 _smf.CurrentSession = hSession;
04036
04037 OldPin = ((ProtocolManager.Param)config.body.param["OldPin"]).vvalue;
04038
04039 NewPin = ((ProtocolManager.Param)config.body.param["NewPin"]).vvalue;
04040
04041
04042 ret = _smf.SetPIN(OldPin, NewPin);
04043
04044
04045 if(ret != ErrorManager.DKMS_OK)
04046 {
04047 _pm.XMLTXParser_Set_Error(ret);
04048 }
04049
04050 else
04051 {
04053
04054
04055 _pm.XMLTXParser_Set_Start("DKMS_SetPIN", 1);
04056
04057 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04058
04059 _pm.XMLTXParser_Set_End();
04060 }
04061 }
04062
04066 private void CS_InitPIN()
04067 {
04068 UInt32 ret = ErrorManager.DKMS_OK;
04069
04070 UInt32 hSession;
04071 string Pin;
04072
04073
04075
04076
04078
04079 hSession = UInt32.Parse(((ProtocolManager.Param)config.body.param["hSession"]).vvalue);
04080 _smf.CurrentSession = hSession;
04081
04082 Pin = ((ProtocolManager.Param)config.body.param["Pin"]).vvalue;
04083
04084
04085 ret = _smf.InitPIN(Pin);
04086
04087
04088 if(ret != ErrorManager.DKMS_OK)
04089 {
04090 _pm.XMLTXParser_Set_Error(ret);
04091 }
04092
04093 else
04094 {
04096
04097
04098 _pm.XMLTXParser_Set_Start("DKMS_InitPIN", 1);
04099
04100 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04101
04102 _pm.XMLTXParser_Set_End();
04103 }
04104 }
04105
04109 private void CS_InitToken()
04110 {
04111 UInt32 ret = ErrorManager.DKMS_OK;
04112
04113 UInt32 slotID;
04114 string Pin;
04115 string Label;
04116
04117
04119
04120
04122
04123 slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
04124
04125 Pin = ((ProtocolManager.Param)config.body.param["Pin"]).vvalue;
04126
04127 Label = ((ProtocolManager.Param)config.body.param["Label"]).vvalue;
04128 Label = Label.Substring(0, Label.Length - 1);
04129
04130
04131 ret = _stmf.InitToken(slotID, Pin, Label);
04132
04133
04134 if(ret != ErrorManager.DKMS_OK)
04135 {
04136 _pm.XMLTXParser_Set_Error(ret);
04137 }
04138
04139 else
04140 {
04142
04143
04144 _pm.XMLTXParser_Set_Start("DKMS_InitToken", 1);
04145
04146 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04147
04148 _pm.XMLTXParser_Set_End();
04149 }
04150 }
04151
04155 private void CS_GetMechanismInfo()
04156 {
04157 UInt32 ret = ErrorManager.DKMS_OK;
04158
04159 UInt32 slotID;
04160 CryptoCore.Smf.CK_MECHANISM_TYPE type;
04161
04162 CryptoCore.Stmf.CK_MECHANISM_INFO pInfo;
04163
04164
04166
04167
04168
04170
04171 slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
04172
04173 type = (CryptoCore.Smf.CK_MECHANISM_TYPE)int.Parse(((ProtocolManager.Param)config.body.param["type"]).vvalue);
04174
04176
04178
04179 pInfo = new CryptoCore.Stmf.CK_MECHANISM_INFO();
04180
04181
04182 ret = _stmf.GetMechanismInfo(slotID, type, out pInfo);
04183
04184
04185 if(ret != ErrorManager.DKMS_OK)
04186 {
04187 _pm.XMLTXParser_Set_Error(ret);
04188 }
04189
04190 else
04191 {
04193
04194
04195 _pm.XMLTXParser_Set_Start("DKMS_GetMechanismInfo", 2);
04196
04197 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04198 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
04199 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.flags", ProtocolManager.PARAM_TYPE.INT32, pInfo.flags.ToString());
04200 _pm.XMLTXParser_Set_ParamAtomic(2, "pInfo.ulMaxKeySize", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMaxKeySize.ToString());
04201 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.ulMinKeySize", ProtocolManager.PARAM_TYPE.UINT32, pInfo.ulMinKeySize.ToString());
04202 _pm.XMLTXParser_Set_EndParamStruct();
04203
04204 _pm.XMLTXParser_Set_End();
04205 }
04206 }
04207
04211 private void CS_GetSlotInfo()
04212 {
04213 UInt32 ret = ErrorManager.DKMS_OK;
04214
04215 UInt32 slotID;
04216
04217 CryptoCore.Stmf.CK_SLOT_INFO pInfo;
04218
04219
04221
04222
04224
04225 slotID = UInt32.Parse(((ProtocolManager.Param)config.body.param["slotID"]).vvalue);
04226
04228
04230
04231 pInfo = new CryptoCore.Stmf.CK_SLOT_INFO();
04232
04233
04234 ret = _stmf.GetSlotInfo(slotID, out pInfo);
04235
04236
04237 if(ret != ErrorManager.DKMS_OK)
04238 {
04239 _pm.XMLTXParser_Set_Error(ret);
04240 }
04241
04242 else
04243 {
04245
04246
04247 _pm.XMLTXParser_Set_Start("DKMS_GetSlotInfo", 2);
04248
04249 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04250 _pm.XMLTXParser_Set_StartParamStruct(1, "pInfo", ProtocolManager.PARAM_TYPE.STRUCT);
04251 _pm.XMLTXParser_Set_StartParamStruct(0, "pInfo.firmwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
04252 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.firmwareVersion.major", ProtocolManager.PARAM_TYPE.UINT32, pInfo.firmwareVersion.major.ToString());
04253 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.firmwareVersion.minor", ProtocolManager.PARAM_TYPE.UINT32, pInfo.firmwareVersion.minor.ToString());
04254 _pm.XMLTXParser_Set_EndParamStruct();
04255 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.flags", ProtocolManager.PARAM_TYPE.UINT32, pInfo.flags.ToString());
04256 _pm.XMLTXParser_Set_StartParamStruct(2, "pInfo.hardwareVersion", ProtocolManager.PARAM_TYPE.STRUCT);
04257 _pm.XMLTXParser_Set_ParamAtomic(0, "pInfo.hardwareVersion.major", ProtocolManager.PARAM_TYPE.UINT32, pInfo.hardwareVersion.major.ToString());
04258 _pm.XMLTXParser_Set_ParamAtomic(1, "pInfo.hardwareVersion.minor", ProtocolManager.PARAM_TYPE.UINT32, pInfo.hardwareVersion.minor.ToString());
04259 _pm.XMLTXParser_Set_EndParamStruct();
04260 _pm.XMLTXParser_Set_ParamAtomic(3, "pInfo.manufacturerID", ProtocolManager.PARAM_TYPE.STRING, pInfo.manufacturerID);
04261 _pm.XMLTXParser_Set_ParamAtomic(4, "pInfo.slotDescription", ProtocolManager.PARAM_TYPE.STRING, pInfo.slotDescription);
04262 _pm.XMLTXParser_Set_EndParamStruct();
04263
04264 _pm.XMLTXParser_Set_End();
04265 }
04266 }
04267
04271 private void CS_GetSlotList()
04272 {
04273 UInt32 ret = ErrorManager.DKMS_OK;
04274
04275 bool tokenPresent;
04276
04277 UInt32[] SlotList;
04278
04279
04281
04282
04284
04285 if (((ProtocolManager.Param)config.body.param["tokenPresent"]).vvalue != true.ToString())
04286 tokenPresent = false;
04287 else
04288 tokenPresent = true;
04289
04290
04291 ret = _stmf.GetSlotList(tokenPresent, out SlotList);
04292
04293
04294 if(ret != ErrorManager.DKMS_OK)
04295 {
04296 _pm.XMLTXParser_Set_Error(ret);
04297 }
04298
04299 else
04300 {
04302
04303
04304 _pm.XMLTXParser_Set_Start("DKMS_GetSlotList", 2);
04305
04306 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04307 _pm.XMLTXParser_Set_StartParamArray(1, "SlotList", ProtocolManager.PARAM_TYPE.UINT32, (UInt32)SlotList.Length, 0);
04308 for(int i = 0; i < SlotList.Length; i++)
04309 _pm.XMLTXParser_Set_ParamAtomic((UInt32)i, "SlotList[" + i.ToString() + "]", ProtocolManager.PARAM_TYPE.UINT32, SlotList[i].ToString());
04310 _pm.XMLTXParser_Set_EndParamArray();
04311
04312 _pm.XMLTXParser_Set_End();
04313 }
04314 }
04315
04320 private void CS_TestDeviceComunication()
04321 {
04322 UInt32 ret = ErrorManager.DKMS_OK;
04323
04324 string deviceName;
04325
04326
04328
04329
04331
04332 deviceName = ((ProtocolManager.Param)config.body.param["deviceName"]).vvalue;
04333
04335
04336 if(deviceName != "CryptoService")
04337 {
04338 ret = ErrorManager.DKMS_DEVICE_NOT_FOUND;
04339 }
04340
04341 _pm.XMLTXParser_Set_Start("DKMS_TestDeviceComunication", 1);
04342
04343 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04344
04345 _pm.XMLTXParser_Set_End();
04346 }
04347
04351 private void CS_SetPolicy()
04352 {
04353 UInt32 ret = ErrorManager.DKMS_OK;
04354
04355 UInt32 count;
04356
04357 lock (typeof(Dispatcher))
04358 {
04360
04361
04363
04364 count = ((ProtocolManager.Param)config.body.param["PMethods"]).XDim;
04365
04366
04367 string delimStr = "|";
04368 char[] delimiter = delimStr.ToCharArray();
04369
04370 _c.adminsgc.SyncAGContainer.Clear();
04371 _c.controllersgc.SyncCGContainer.Clear();
04372 _c.custodiansgc.SyncCGContainer.Clear();
04373 _c.insertersgc.SyncIGContainer.Clear();
04374 _c.operatorsgc.SyncOGContainer.Clear();
04375 _c.swadminsgc.SyncSGContainer.Clear();
04376 _c.swdevelopersgc.SyncSGContainer.Clear();
04377 _c.techniciansgc.SyncTGContainer.Clear();
04378 _c.adminsgc.SyncAGContainer.Add("SetPolicy", string.Empty);
04379 _c.adminsgc.SyncAGContainer.Add("TestDeviceComunication", string.Empty);
04380 _c.swadminsgc.SyncSGContainer.Add("SetPolicy", string.Empty);
04381 _c.swadminsgc.SyncSGContainer.Add("TestDeviceComunication", string.Empty);
04382 _c.swadminsgc.SyncSGContainer.Add("CloseSession", string.Empty);
04383
04384 try
04385 {
04386 for (int i = 0; i < (int)count; i++)
04387 {
04388 string[] policies = ((ProtocolManager.Param)config.body.param["PMethods[" + i.ToString() + "]"]).vvalue.Split(delimiter);
04389 switch (policies[1])
04390 {
04391 case "dkms_swadmins":
04392 if (!_c.swadminsgc.SyncSGContainer.ContainsKey(policies[0]))
04393 _c.swadminsgc.SyncSGContainer.Add(policies[0], string.Empty);
04394 break;
04395 case "dkms_admins":
04396 if (!_c.adminsgc.SyncAGContainer.ContainsKey(policies[0]))
04397 _c.adminsgc.SyncAGContainer.Add(policies[0], string.Empty);
04398 break;
04399 case "dkms_controllers":
04400 if (!_c.controllersgc.SyncCGContainer.ContainsKey(policies[0]))
04401 _c.controllersgc.SyncCGContainer.Add(policies[0], string.Empty);
04402 break;
04403 case "dkms_custodians":
04404 if (!_c.custodiansgc.SyncCGContainer.ContainsKey(policies[0]))
04405 _c.custodiansgc.SyncCGContainer.Add(policies[0], string.Empty);
04406 break;
04407 case "dkms_inserters":
04408 if (!_c.insertersgc.SyncIGContainer.ContainsKey(policies[0]))
04409 _c.insertersgc.SyncIGContainer.Add(policies[0], string.Empty);
04410 break;
04411 case "dkms_swdevelopers":
04412 if (!_c.swdevelopersgc.SyncSGContainer.ContainsKey(policies[0]))
04413 _c.swdevelopersgc.SyncSGContainer.Add(policies[0], string.Empty);
04414 break;
04415 case "dkms_technicians":
04416 if (!_c.techniciansgc.SyncTGContainer.ContainsKey(policies[0]))
04417 _c.techniciansgc.SyncTGContainer.Add(policies[0], string.Empty);
04418 break;
04419 case "dkms_operators":
04420 if (!_c.operatorsgc.SyncOGContainer.ContainsKey(policies[0]))
04421 _c.operatorsgc.SyncOGContainer.Add(policies[0], string.Empty);
04422 break;
04423 }
04424 }
04425 }
04426 catch
04427 {
04428 ret = ErrorManager.DKMS_GENERAL_ERROR;
04429 }
04430 finally
04431 {
04432 if (ret != ErrorManager.DKMS_OK)
04433 {
04434 _c.adminsgc.SyncAGContainer.Clear();
04435 _c.controllersgc.SyncCGContainer.Clear();
04436 _c.custodiansgc.SyncCGContainer.Clear();
04437 _c.insertersgc.SyncIGContainer.Clear();
04438 _c.operatorsgc.SyncOGContainer.Clear();
04439 _c.swadminsgc.SyncSGContainer.Clear();
04440 _c.swdevelopersgc.SyncSGContainer.Clear();
04441 _c.techniciansgc.SyncTGContainer.Clear();
04442 _c.adminsgc.SyncAGContainer.Add("SetPolicy", string.Empty);
04443 _c.adminsgc.SyncAGContainer.Add("TestDeviceComunication", string.Empty);
04444 _c.swadminsgc.SyncSGContainer.Add("SetPolicy", string.Empty);
04445 _c.swadminsgc.SyncSGContainer.Add("TestDeviceComunication", string.Empty);
04446 _c.swadminsgc.SyncSGContainer.Add("CloseSession", string.Empty);
04447 }
04448 }
04449
04451
04452
04453 _pm.XMLTXParser_Set_Start("DKMS_SetPolicy", 1);
04454
04455 _pm.XMLTXParser_Set_ParamAtomic(0, "ret", ProtocolManager.PARAM_TYPE.UINT32, ret.ToString());
04456
04457 _pm.XMLTXParser_Set_End();
04458 }
04459 }
04460
04461 #endregion
04462
04463 #region Dispatcher class fields
04464
04466 private CryptoCore.Stmf _stmf;
04467
04469 private CryptoCore.Smf _smf;
04470
04472 private Containers _c;
04473
04475 private CryptoCore _cc;
04476
04478 private ProtocolManager _pm;
04479
04481 private ProtocolManager.Config config;
04482
04483 #endregion
04484 }
04485 }