﻿<!-- 
  var publishOID= "1.2.804.2.1.1.1.11.32206929.6.4.0";
  var publishCodeOID= "1.2.804.2.1.1.1.11.32206929.6.4.1";
  
  var CRYPT_STRING_HEX = 0x00000004;
  var EXTENTION_NO_CRITICAL = 0x00000000;
  
  var SIMPLE_TEMPLATE = "0";
  var COMPLEX_TEMPLATE = "1";
  
  var ALGORITHM_RSA = "1";
  var ALGORITHM_GOST = "2";
  var ALGORITHM_DSTUPBRSA = "3";
  var ALGORITHM_DSTUPBDH = "4";
  var ALGORITHM_DSTUONBRSA = "5";
  var ALGORITHM_DSTUONBDH = "6";
    
	var CLIENT_TITLE				= 0;
	var CLIENT_TEMPLATE_CLASS       = 1;
	var CLIENT_ALGORITHMCODE		= 2;
	var CLIENT_OID					= 3;
	var CLIENT_ISSESSIONENCRYPTION	= 4;
	var CLIENT_KEY_SIZE_MIN			= 5;
	var CLIENT_KEY_SIZE_MAX			= 6;
	var CLIENT_KEY_SIZE_DEFAULT		= 7;
	var CLIENT_CPLIST				= 8;
  var CLIENT_PRINT_AGREEMENT = 9;
  
	var ALG_HASH_34311 = 0x8052;
	var ALG_HASH_SHA1 = 0x8004;
	
	var XEKL_KEYSIZE_MIN=1;
	var XEKL_KEYSIZE_MAX=2;
	var XEKL_KEYSIZE_INC=3;
	var XEKL_KEYSIZE_DEFAULT=4;
	var XEKL_KEYSPEC_KEYX=1;
	var XEKL_KEYSPEC_SIG=2;
	
	var XECT_EXTENSION_V1=1;
	var XECT_EXTENSION_V2=2;
	
	var XECR_PKCS10_V2_0=1;

    var XECP_STRING_PROPERTY=1;		

    var CERT_FRIENDLY_NAME_PROP_ID=11;
	
	var AT_KEYEXCHANGE=1;
	var AT_SIGNATURE=2;
	
	var PROV_DSS=3;
	var PROV_DSS_DH=13;
	
	var CRYPT_EXPORTABLE=1;
	var CRYPT_USER_PROTECTED=2;
	
    var CRYPT_4145_BASIS_TYPE_PB=0;           //Полиномиальный базис
    var CRYPT_4145_BASIS_TYPE_ONB=0x00001000; //Оптимальный нормальный базис
	
  var KEY_LEN_MIN_DEFAULT=384;
  var KEY_LEN_MAX_DEFAULT=16384;
  var KEY_LEN_MY_DEFAULT=1024;
  var KEY_LEN_INC_DEFAULT=8;
		

	function SplashMassage(sMessage) {
	  		    window.status=sMessage;
	}
	function CloseSplashMassage(){
	      window.status="";
	}
	function loadXEnroll(sContinueCmd) 
		{
	
		    spnXEnroll.innerHTML="";
		
		    var sCPU=navigator.cpuClass.toLowerCase();
		    if ("x86"!=sCPU && "ia64"!=sCPU) 
		    {
    			alert(eval(L_BadCPU_ErrorMessage));
	    		disableAllControls();
		    	return;
		    }
  	//+ "  Codebase=\""+location.protocol+"//"+location.host+"/certcontrol/xenrlinf.cab#Version=5,131,3686,0\"\n"
			var sControl="<Object \n"
			+ "  ClassID=\"clsid:127698e4-e730-4e5c-a2b1-21490a70c8a1\"\n"
			+ "  Codebase=\"/downloads/MSCertEnroll/xenrlinf.cab\"\n"
			+ "  ID=XEnroll\n"
			+ "></Object>";
		try
		{
			spnXEnroll.innerHTML=sControl;
		}
		catch(e)
		{
			if ((e.message.indexOf("file") >-1 ) || (e.message.indexOf("файл") >-1 ))
			{
				alert(Message_XenrollAbsent);
				throw(e);
			}
		}
	
		setTimeout("loadXEnrollPhase2(\""+sContinueCmd+"\")", 1);
	}
	
	function loadXEnrollPhase2(sContinueCmd) {
		// continued from above
		
		// is the control loaded?
		if (4!=XEnroll.readyState) 
		{ 
			SplashMassage("Please wait...");
			setTimeout("loadXEnrollPhase2(\""+sContinueCmd+"\")", 500);
		} 
		else 
		{
			CloseSplashMassage();
		
			var nResult = ConfirmXEnrollLoaded();
			if (0!=nResult)
			{
				if (438 == nResult) 
					alert(L_ControlLoadFailed_ErrorMessage);
				else 
					alert(eval(L_ControlLoadFailedEx_ErrorMessage));
				disableAllControls();
				return;
			}
			execScript(sContinueCmd, "JavaScript");
		}
	}

    function ConfirmXEnrollLoaded()
    {
        try{
            XEnroll.HashAlgID;
            return 0;
        }
        catch(e)
        {
            return e.number; 
        }
    }
     function disableAllControls() 
  {
    // some pages do not have any controls
    if (null==document.forms(0)) 
      return ;
  
  // disable every control on the page
    var nCount=document.forms(0).elements.length;
    var nIndex;
    for (nIndex=0; nIndex<nCount; nIndex++)  //>
      document.forms(0).elements(nIndex).disabled=true;
  }
 
	function postLoadPhase2() 
	{
	
    }
        
    function InstallCertificate(pksc7)
    {
        var XEnroll;
        try
        {
            try
            {
                XEnroll = new ActiveXObject('CEnroll.CEnroll.2'); 
                XEnroll.acceptPKCS7(pksc7);
            }
  	        catch(e)
  	        {
  	            alert("Error = "+e.Description+" Number"+e.Number);
  	        }
        }
        finally
        {
        }
    }
        
    var objData;
	function RequestCertificate(outputcontrol, templateID, commonName, userFriendlyName, providerName, providerType, keySize, isKeySecurity)
  	{
  	    objData = '';
  	    silverLightControl = document.getElementById("Xaml1");
  	    var XEnroll;
  	    try
  	    {
  	        try
  	        {
  	            XEnroll = new ActiveXObject('CEnroll.CEnroll.2');
	            XEnroll.ProviderName = providerName;
    	        XEnroll.ProviderType = providerType;
	            if ("" != userFriendlyName)
		            XEnroll.addBlobPropertyToCertificate(CERT_FRIENDLY_NAME_PROP_ID, XECP_STRING_PROPERTY,userFriendlyName);
  	    

  	            if( (providerType==PROV_DSS) || 
  	                (providerType==PROV_DSS_DH) || 
  	                ((providerType>=804) && (providerType<=808)))
  	            {
		            XEnroll.KeySpec=AT_SIGNATURE;
		            XEnroll.HashAlgID = ALG_HASH_34311;
		        }
	            else 
	            {
	                XEnroll.KeySpec=AT_KEYEXCHANGE;
	                XEnroll.HashAlgID = ALG_HASH_SHA1;
	            }

                XEnroll.GenKeyFlags = keySize << 16;
	            if (isKeySecurity == "1")
		            XEnroll.GenKeyFlags |= CRYPT_USER_PROTECTED;

                XEnroll.GenKeyFlags |= CRYPT_EXPORTABLE;
            
//alert("providerType = "+providerType);
//alert("userFriendlyName = "+userFriendlyName);
//alert("templateID = "+templateID);
//alert("commonName = "+commonName);
//alert("keySize = "+keySize);
//alert("providerName = "+providerName);

                var nResult=CreateRequest(XEnroll, XECR_PKCS10_V2_0, "CN="+commonName, ""); 
                if (0 != nResult)
   		    	    if (0 != (0x8010006e^nResult))
    		    	    handleError(nResult);
  	        }
  	        catch(e)
  	        {
  	            alert("Error = "+e.Description+" Number"+e.Number);
  	        }
  	    }
  	    finally
  	    {
  	        XEnroll.reset();
  	    }
  	    eval(outputcontrol);
  	}
  	
	function CreateRequest(XEnroll, lFlags, sDistinguishedName, sCertUsage)
	{
	    try
	    {
		    XEnroll.ReuseHardwareKeyIfUnableToGenNew = false;
		    objData = XEnroll.CreateRequest(lFlags, sDistinguishedName, sCertUsage);
		    return 0;
		}
		catch(e)
		{
		    return e.Number;
		}
	}
	
	
  function StandardRequest(objData, commonName, userFriendlyName, template, providerName, providerType,keySize, isKeySecurity, toPublish,toCodePublish)
  {
		  var nResult;
	    try
	    {
    	    XEnroll.addCertTypeToRequestEx(XECT_EXTENSION_V1, ParseString(template, CLIENT_TITLE, ";"), 0, false, 0);
	        XEnroll.ProviderName = providerName;
    	    XEnroll.ProviderType = providerType;
	        if ("" != userFriendlyName)
		        XEnroll.addBlobPropertyToCertificate(CERT_FRIENDLY_NAME_PROP_ID, XECP_STRING_PROPERTY,userFriendlyName);
			
    	 /*  if (ParseString(template, CLIENT_ISSESSIONENCRYPTION,";") != "1")
	    	    XEnroll.KeySpec = AT_SIGNATURE;
	        else
		       {
		         XEnroll.KeySpec = AT_KEYEXCHANGE;
			}
		*/		       
		   if((providerType==PROV_DSS) || (providerType==PROV_DSS_DH) || ( (providerType>=804) && (providerType<=808) && (ParseString(template, CLIENT_ISSESSIONENCRYPTION,";") != "1") ))
		        XEnroll.KeySpec=AT_SIGNATURE;
	        else XEnroll.KeySpec=AT_KEYEXCHANGE;

    	    XEnroll.HashAlgID = GetCurrHash(template);
	
	        XEnroll.GenKeyFlags = keySize << 16;
	        if (isKeySecurity == "1")
		        XEnroll.GenKeyFlags |= CRYPT_USER_PROTECTED;
		  
		  

          XEnroll.GenKeyFlags |= CRYPT_EXPORTABLE;
    
         if(toPublish == true)
                XEnroll.addExtensionToRequest(EXTENTION_NO_CRITICAL,publishOID,XEnroll.stringToBinary(CRYPT_STRING_HEX,"01"));
          if(toCodePublish == true)
                XEnroll.addExtensionToRequest(EXTENTION_NO_CRITICAL,publishCodeOID,XEnroll.stringToBinary(CRYPT_STRING_HEX,"01"));                            
	   
	        nResult=CreateRequest(objData, XECR_PKCS10_V2_0, "CN="+commonName, ""); // ask VB to do it, since it can handle errors
			// deal with an error if there was one
   	    	if (0 != nResult)
   		    	if (0 != (0x8010006e^nResult))
    		    	handleError(nResult);
		}
		catch(e)
		{
			alert(Message_ErrorRequest+e.number+" : "+e.description);
		}
		finally
		{
			XEnroll.reset();
		}
		return nResult;
    }
    
	   	
	function handleError(nResult) 
	{
		handleError2(nResult, 0);
	}

	function handleError2(nResult, sSugCauseIN) 
	{ 	    
		var sSugCause=L_SugCauseNone_ErrorMessage;
		var sErrorName=L_ErrNameUnknown_ErrorMessage;
		// analyze the error - funny use of XOR ('^') because obvious choice '==' doesn't work
		if (0==(0x80090008^nResult)) {
			sErrorName="NTE_BAD_ALGID";
			sSugCause=L_SugCauseBadSetting2_ErrorMessage;
		} else if (0==(0x80090016^nResult)) {
			sErrorName="NTE_BAD_KEYSET";
		} else if (0==(0x80090019^nResult)) {
		    sErrorName="NTE_KEYSET_NOT_DEF";
		    sSugCause=L_SugCauseBadCSP_ErrorMessage;
		} else if (0==(0x80090020^nResult)) {
			sErrorName="NTE_FAIL";
			sSugCause=L_SugCauseBadCSP_ErrorMessage;
		} else if (0==(0x80090023^nResult)) {
			sErrorName="NTE_TOKEN_KEYSET_STORAGE_FULL";
			sSugCause=L_SugCauseKeysetFull_ErrorMessage;
		} else if (0==(0x80090009^nResult)) {
			sErrorName="NTE_BAD_FLAGS";
			sSugCause=L_SugCauseBadSetting2_ErrorMessage;
		} else if (0==(0x8009000F^nResult)) {
			sErrorName="NTE_EXISTS";
			sSugCause=L_SugCauseExistKeyContainer_ErrorMessage;
		} else if (0==(0x80092002^nResult)) {
			sErrorName="CRYPT_E_BAD_ENCODE";
		} else if (0==(0x80092022^nResult)) {
			sErrorName="CRYPT_E_INVALID_IA5_STRING";
			sSugCause=L_SugCauseBadChar_ErrorMessage;
		} else if (0==(0x80092023^nResult)) {
			sErrorName="CRYPT_E_INVALID_X500_STRING";
			sSugCause=L_SugCauseBadChar_ErrorMessage;
		} else if (0==(0x80070003^nResult)) {
			sErrorName="ERROR_PATH_NOT_FOUND";
			sSugCause=L_SugCauseBadFileName_ErrorMessage;
		} else if (0==(0x80070103^nResult)) {
			sErrorName="ERROR_NO_MORE_ITEMS";
			sSugCause=L_SugCauseBadHash_ErrorMessage;
		} else if (0==(0x8007007B^nResult)) {
			sErrorName="ERROR_INVALID_NAME";
			sSugCause=L_SugCauseBadFileName_ErrorMessage;
		} else if (0==(0x80070015^nResult)) {
			sErrorName="ERROR_NOT_READY";
			sSugCause=L_SugCauseBadDrive_ErrorMessage;
		} else if (0==(0x8007007F^nResult)) {
			sErrorName="ERROR_PROC_NOT_FOUND";
			sSugCause=L_DownLevelClients_ErrorMessage;
		} else if (0==(0x800704C7^nResult)) { 
			sErrorNamge="ERROR_CANCELLED";
			sSugCause=L_SugCauseCancelled_ErrorMessage;
		} else if (0==(0x80100006^nResult)) {
			sErrorName = "SCARD_E_NO_MEMORY";
			sSugCause = L_SCARD_E_NOMEMORYMSG_ErrorMessage;
		} else if (0==(0x80100007^nResult)) {
			sErrorName = "SCARD_F_WAITED_TOO_LONG";
			sSugCause = L_SCARD_F_WAITEDTOOLONG_ErrorMessage;
		} else if (0==(0x80100008^nResult)) {
			sErrorName = "SCARD_E_INSUFFICIENT_BUFFER";
			sSugCause = L_SCARD_E_INSUFFICIENTBUFFER_ErrorMessage;
		} else if (0==(0x80100009^nResult)) {
			sErrorName = "SCARD_E_UNKNOWN_READER";
			sSugCause = L_SCARD_E_UNKNOWNREADER_ErrorMessage;
		} else if (0==(0x8010000C^nResult)) {
			sErrorName = "SCARD_E_NO_SMARTCARD";
			sSugCause = L_SCARD_E_NOSMARTCARD_ErrorMessage;
		} else if (0==(0x8010000D^nResult)) {
			sErrorName = "SCARD_E_UNKNOWN_CARD";
			sSugCause = L_SCARD_E_UNKNOWNCARD_ErrorMessage;
		} else if (0==(0x80100010^nResult)) {
			sErrorName = "SCARD_E_NOT_READY";
			sSugCause = L_SCARD_E_NOTREADY_ErrorMessage;
		} else if (0==(0x80100013^nResult)) {
			sErrorName = "SCARD_F_COMM_ERROR";
			sSugCause = L_SCARD_F_COMMERROR_ErrorMessage;
		} else if (0==(0x8010001D^nResult)) {
			sErrorName = "SCARD_E_NO_SERVICE";
			sSugCause = L_SCARD_E_NOSERVICE_ErrorMessage;
		} else if (0==(0x8010001E^nResult)) {
			sErrorName = "SCARD_E_SERVICE_STOPPED";
			sSugCause = L_SCARD_E_SERVICESTOPPED_ErrorMessage;
		} else if (0==(0x8010002E^nResult)) {
			sErrorName = "SCARD_E_NO_READERS_AVAILABLE";
			sSugCause = L_SCARD_E_NOREADERSAVAILABLE_ErrorMessage;
		} else if (0==(0x8010002F^nResult)) {
			sErrorName = "SCARD_E_COMM_DATA_LOST";
			sSugCause = L_SCARD_E_COMMDATALOST_ErrorMessage;
		} else if (0==(0x80100030^nResult)) {
			sErrorName = "SCARD_E_NO_KEY_CONTAINER";
			sSugCause = L_SCARD_E_NOKEYCONTAINER_ErrorMessage;
		} else if (0==(0x80100067^nResult)) {
			sErrorName = "SCARD_W_UNPOWERED_CARD";
			sSugCause = L_SCARD_W_UNPOWEREDCARD_ErrorMessage;
		} else if (0==(0x80100069^nResult)) {
			sErrorName = "SCARD_W_REMOVED_CARD";
			sSugCause = L_SCARD_W_REMOVEDCARD_ErrorMessage;
		} else if (0==(0x8010006B^nResult)) {
			sErrorName = "SCARD_W_WRONG_CHV";
			sSugCause = L_SCARD_W_WRONGCHV_ErrorMessage;
		} else if (0==(0x8010006C^nResult)) {
			sErrorName = "SCARD_W_CHV_BLOCKED";
			sSugCause = L_SCARD_W_CHVBLOCKED_ErrorMessage;
		} else if (0==(0x8010006D^nResult)) {
			sErrorName = "SCARD_W_EOF";
			sSugCause = L_SCARD_W_EOF_ErrorMessage;
		} else if (0==(0x8010006E^nResult)) {
			sErrorName = "SCARD_W_CANCELLED_BY_USER";
			sSugCause = L_SCARD_W_CANCELLEDBYUSER_ErrorMessage;
		} else if (0==(0x8010006F^nResult)) {
			sErrorName = "SCARD_W_CARD_NOT_AUTHENTICATED";
			sSugCause = L_SCARD_W_CARDNOTAUTHENTICATED_ErrorMessage;
		} else if (0==(0x80090024^nResult)) {
			sErrorName = "NTE_TEMPORARY_PROFILE";
			sSugCause = L_SugCauseNoProfile_ErrorMessage;
		} else if (0==(0xFFFFFFFF^nResult)) {
			sErrorName=L_ErrNameNoFileName_ErrorMessage;
			sSugCause=L_SugCauseNoFileName_ErrorMessage;
		} else if (0==(0x800B010A^nResult)) {
			sErrorName = "CERT_E_CHAINING";
			sSugCause=L_SugCauseCAExSignerNotFound_ErrorMessage;
		} else if (0==(0x800B0109^nResult)) {
			sErrorName = "CERT_E_UNTRUSTEDROOT";
			sSugCause=L_SugCauseCAExNotTrusted_ErrorMessage;
		} else if (0==(0x80092010^nResult)) {
			sErrorName = "CHAIN_STATUS_REVOKED";
			sSugCause=L_ChainRevoked;
		} else if (0==(0x80092012^nResult)) {
			sErrorName="CHAIN_STATUS_REVOCATION_NO_CHECK";
			sSugCause=L_CRLNoCheck;
		} else if (0==(0x80092013^nResult)) {
			sErrorName="CHAIN_STATUS_REVOCATION_OFFLINE";
			sSugCause=L_CRLSubUnavailable;
		} else if (0==(0x80096019^nResult)) {
			sErrorName="CHAIN_STATUS_INVALID_BASIC_CONSTRAINTS";
			sSugCause=L_InvalidBasicConstraints;
		} else if (0==(0x80096004^nResult)) {
			sErrorName="CHAIN_STATUS_INVALID_SIGNATURE";
			sSugCause=L_SignatureCertError;
		} else if (0==(0x800B0101^nResult)) {
			sErrorName="CHAIN_STATUS_EXPIRED";
			sSugCause=L_CertificateExpired;
		} else if (0==(0x800B0102^nResult)) {
			sErrorName="CHAIN_STATUS_NESTED_VALIDITY_PERIOD";
			sSugCause=L_ValidityPeriod;
		} else if (0==(0x800B0109^nResult)) {
			sErrorName="CHAIN_STATUS_UNTRUSTEDROOT";
			sSugCause=L_RootNotTrusted;
		} else if (0==(0x800B010A^nResult)) {
			sErrorName="CHAIN_STATUS_PARTIAL_CHAINING";
			sSugCause=L_PartialChaining;
		} else if (0==(0x800B0110^nResult)) {
			sErrorName="CHAIN_STATUS_INVALID_USAGE";
			sSugCause=L_InvalidUsage;
		} else if (0==(0x800B0113^nResult)) {
			sErrorName="CHAIN_STATUS_INVALID_POLICY";
			sSugCause=L_InvalidPolicy;
		} else if (0==(0x800B0114^nResult)) {
			sErrorName="CHAIN_STATUS_INVALID_NAME";
			sSugCause=L_InvalidName;
		} else if (0==(0x8000FFFF^nResult)) {
			sErrorName="E_UNEXPECTED";
		} else if (0==(0x00000046^nResult)) {
			sErrorName=L_ErrNamePermissionDenied_ErrorMessage;
			sSugCause=L_SugCausePermissionToWrite_ErrorMessage;
		} else if (0==(0x800710DF^nResult)) {
		    sErrorName = "THE_DEVICE_IS_NOT_READY";
		    sSugCause = L_DEVICE_IS_NOT_READY;
		} 
		var errorMessage = "";
		var errorText = "";
		if (0 !=(0x800704C7^nResult)) 
			errorMessage = Message_HexError+toHex(nResult)+" - "+sErrorName;
	 	if (0 == sSugCauseIN)
			errorText=sSugCause;
		else 
			errorText=sSugCauseIN;
		alert(errorMessage+"\n"+errorText);
	}
-->
