CASA/c_micasad/verbs/WriteSecret.cs

using System;
using System.Collections;
using System.Text;
using System.Threading;
using sscs.verbs;
using sscs.common;
using sscs.cache;
using sscs.constants;

namespace sscs.verbs 
{
    
   /*
    * This class is implementation of WriteSecret call.
    * There will be one instance existing for every call made by the client.  
    */

    class WriteSecret : SSVerb
    {
        private ushort msgId = 0;
        private uint inMsgLen  = 0;
        private uint outMsgLen = 0;
        private uint keyChainIdLen = 0;
        private uint secretIdLen = 0;
        private uint secretValLen = 0;
        private int retCode = 0;
        private string keyChainId;
        private string secretId;
        private byte[] secretVal;
        
        private byte[] inBuf;
        private byte[] outBuf;

		// extension operations
		private uint extId = 0;
#if W32
		private int  luidLow = 0;
		private int  luidHigh = 0;
#endif
        
        /*
        * This method sets the class member with the byte array received.
        */
 
        public void SetMessageContent(byte[] ipcBytes)
        {
           CSSSLogger.ExecutionTrace(this);
           inBuf = ipcBytes;                   
        }

       /*
        * This method does the actual implementation of WriteSecret 
        *   
        */

        public byte[] ProcessRequest(UserIdentifier userId)
        {
			UserIdentifier tempUserId = userId;
                CSSSLogger.ExecutionTrace(this);
                // Message Format decipher - Start
                msgId          = BitConverter.ToUInt16(inBuf,0);
                inMsgLen       = BitConverter.ToUInt32(inBuf,2);
            if( inMsgLen != inBuf.Length )
                throw new FormatException(" MsgLen sent does not match the length of the message received.");
                keyChainIdLen  = BitConverter.ToUInt32(inBuf,6);

                byte[] keyChainIdArr = new byte[keyChainIdLen];
                Array.Copy(inBuf,10,keyChainIdArr,0,keyChainIdLen);
                keyChainId     = Encoding.UTF8.GetString(keyChainIdArr);


                secretIdLen    = BitConverter.ToUInt32(inBuf,
                                 (10 + (int)keyChainIdLen ));
 
                byte[] secretIdArr = new byte[secretIdLen];
                Array.Copy(inBuf,(10+keyChainIdLen+4),secretIdArr,0,secretIdLen);
                secretId = Encoding.UTF8.GetString(secretIdArr);

                secretValLen   = BitConverter.ToUInt32(inBuf, 
                                (14 + ((int)keyChainIdLen)+((int)secretIdLen)));            
                //secretVal      = new byte[secretValLen];				
                string secretValStr = Encoding.UTF8.GetString(inBuf,
                                 (18 + ((int)keyChainIdLen)+((int)secretIdLen)),
                                 (int)secretValLen
                                 );
                secretVal = Encoding.UTF8.GetBytes(secretValStr);
					
				try 
				{
					// get extension ID
					int extLocation = 22 + ((int)keyChainIdLen) + ((int)secretIdLen) + ((int)secretValLen);
					extId = BitConverter.ToUInt32(inBuf, extLocation);
				}
				catch (Exception e)
				{
					//CSSSLogger.ExpLog(e.ToString());
				}
				
				if (extId == 1)
				{
#if W32
					// WINDOWS LUID
					// This is how the Login Capture module on windows, running as System, sets the Desktop Credential.
					// we might be able to change this if/when we abstract the session.	
					// [4 byte extID][4 byte length][4 byte luidLow][4 byte luidHigh]
					luidLow = BitConverter.ToInt32(inBuf, 22 + ((int)keyChainIdLen)+((int)secretIdLen) +(int)secretValLen + 8);
					luidHigh = BitConverter.ToInt32(inBuf, 22 + ((int)keyChainIdLen)+((int)secretIdLen) +(int)secretValLen + 12);
					tempUserId = new WinUserIdentifier(luidLow, luidHigh);
					SecretStore ss = SessionManager.CreateUserSession(tempUserId);
					try 
					{
						ss.AddKeyChain(new KeyChain("SSCS_SESSION_KEY_CHAIN_ID\0"));										
					}
					catch (Exception)
					{

					}
#endif
				}

            try
            {
                string passwd = null;
                KeyChain keyChain = null;
                SecretStore ssStore = SessionManager.GetUserSecretStore(tempUserId);
				if (!ssStore.IsStoreLocked())
				{
					if( ssStore.CheckIfKeyChainExists(keyChainId) )
					{
						keyChain = ssStore.GetKeyChain(keyChainId);
						Secret secret = new Secret(secretId,secretVal);
						if( keyChain.CheckIfSecretExists(secretId) == false)
						{
							keyChain.AddSecret(secret);
							if(ConstStrings.MICASA_DESKTOP_PASSWD == secretId)
							{
								//                            Secret sec = keyChain.GetSecret(secretId);

								KeyValue kv = secret.GetKeyValue(ConstStrings.MICASA_DESKTOP_PASSWD_KEYNAME);
								if( null != kv )
									passwd = kv.GetValue();
								if( null != passwd )
								{
									ssStore.StartPersistenceByDesktopPasswd(passwd);
								}
							}
						}
						else
						{
							Secret masterSecret = keyChain.GetSecret(secretId);
							string oldPasswd = masterSecret.GetKeyValue(ConstStrings.MICASA_DESKTOP_PASSWD_KEYNAME).GetValue();
							masterSecret.MergeSecret(secret);
							//keyChain.RemoveSecret(secretId);
							keyChain.AddSecret(secret);

							KeyValue kv = secret.GetKeyValue(ConstStrings.MICASA_DESKTOP_PASSWD_KEYNAME);
							if( null != kv )
								passwd = kv.GetValue();
							if( ( oldPasswd != null ) && ( passwd != null ) )
							{
								if( oldPasswd != passwd )
								{
									byte[] baPasscode = ssStore.GetPasscodeFromOldDesktopPasswd( oldPasswd );
									if( null != baPasscode )
									{
										ssStore.RewriteDesktopPasswdFile(baPasscode, passwd);
									}
								}
							}
							ssStore.StartPersistenceByDesktopPasswd(passwd);
						}
					}
					else
					{
						retCode = IPCRetCodes.SSCS_E_KEYCHAIN_DOES_NOT_EXIST;
					}
				}
				else
				{
					// do nothing
				}
            }
            catch(UserNotInSessionException)
            { 
                CSSSLogger.DbgLog("In " + CSSSLogger.GetExecutionPath(this) + " Unable to get user's secretstore" );
                retCode = IPCRetCodes.SSCS_E_SYSTEM_ERROR;                
            }   
            catch(Exception e )
            {
                CSSSLogger.ExpLog(e.ToString());
                retCode = IPCRetCodes.SSCS_E_SYSTEM_ERROR;
            }

            try
            {
                msgId = 9;
                outMsgLen = 10;
                outBuf = new byte[10];
                byte[] t = new byte[10];

                t = BitConverter.GetBytes((ushort)msgId);
                Array.Copy(t,0,outBuf,0,2);

                t = BitConverter.GetBytes((uint)outMsgLen);
                Array.Copy(t,0,outBuf,2,4);

                t = BitConverter.GetBytes(retCode);
                Array.Copy(t,0,outBuf,6,4);
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
                throw new FormatException("Unable to form the response " + e.ToString());
            }

            return outBuf;
        }


        /*
         * Gives the name of operation performed. Will be used in case 
         * of error. 
         */
        public string GetVerbName()
        {
            CSSSLogger.ExecutionTrace(this);
            return this.ToString(); 
        }
    }
}