CASA/c_micasad/cache/SecretStore.cs

/***********************************************************************
 * 
 *  Copyright (C) 2005-2006 Novell, Inc. All Rights Reserved.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; version 2.1
 *  of the License.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, Novell, Inc.
 * 
 *  To contact Novell about this file by physical or electronic mail, 
 *  you may find current contact information at www.novell.com.
 * 
 ***********************************************************************/

using System;
using System.Collections;
using System.Threading;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Security.Cryptography;
using System.Text;
using sscs.cache;
using sscs.common;
using sscs.constants;
using sscs.lss;
using sscs.crypto;

#if LINUX
using Novell.CASA.DataEngines.GK;
#endif

namespace sscs.cache
{
    class SecretStore
    {
        internal string secretStoreName; // User name ?
        internal int refCount;
        private uint version;
        private Hashtable tKeyChainList = new Hashtable();
        private Hashtable keyChainList; //= Hashtable.Synchronized(tKeyChainList);
        internal User user;
        private Mutex ssMutex ; //reqd only for refCount
        private int state; // Maintains the state of SS ( keychain
                           // type availability). TODO: Convert to a class.

		private static int STATE_NOT_DEFINED = 0;
		private static int STATE_OK	= 1;
		private static int STATE_LOCKED = 2;

        private LocalStorage lss = null; 
        bool bIsStorePersistent = false; 

        private DateTime createTime;
        public DateTime CreateTime
        {
            get
            {
                return createTime;
            }
            set
            {
                createTime = value;
            }
        }

        ~SecretStore()
        {
           ssMutex.Close();
        }

        internal SecretStore(User ssUser)
        {
            secretStoreName = ssUser.GetUserName();
            version         = 1;
            state           = STATE_NOT_DEFINED;
            user            = ssUser;
            refCount        = 0;
            keyChainList    = Hashtable.Synchronized(tKeyChainList);
            
            ssMutex = new Mutex();  
        }

        internal bool IsStorePersistent()
        {
            return bIsStorePersistent;
        }
	
		public bool StopPersistence()
		{
			if(lss != null && bIsStorePersistent == true)
			{
				lss.StopPersistence();
				lss = null;
				bIsStorePersistent = false;
			}			
			return true;
		}
  
		public bool IsStoreLocked()
		{
			if (state == STATE_LOCKED)
				return true;
			else
				return false;
		}

		public void LockStore()
		{
			state = STATE_LOCKED;
		}

		public bool UnlockStore(string sDesktopPassword, string sMasterPassword)
		{
			if (sDesktopPassword != null)
			{
				// verify Desktop password
				//state = STATE_OK;
				//return true;
			}


			if (sMasterPassword != null)
			{
				// verify MasterPassword
				if (SetMasterPassword(sMasterPassword))
				{
					state = STATE_OK;
					return true;
				}
			}

			return false;
		}
		
		internal bool StartPersistenceByDesktopPasswd(string desktopPasswd)
        {
			CSSSLogger.DbgLog("StartPersistenceByDesktopPasswd - Called");

			// make sure we have a user home directory
			if (GetUserHomeDirectory() == null || GetUserHomeDirectory().Length < 1)
			{				
				CSSSLogger.DbgLog("StartPersistenceByDesktopPasswd - No Home directory yet");
				return false;
			}
			else
			{
				if (!Directory.Exists(GetUserHomeDirectory()))
				{
					CSSSLogger.DbgLog("StartPersistenceByDesktopPasswd - Home directory is not created yet");
					return false;
				}
			}


            try
            {
                byte[] baPasscode;
                /* Persistence could have started because the user
                 * could have set master password.
                 */
                if(lss != null && bIsStorePersistent == true)
                {
                    /* Verify passcode and if validation fails, rewrite 
                     * desktop file.
                     */
                    if(File.Exists(GetPasscodeByDesktopFilePath()))
                    {
                    }
                    else
                    {
                        /* Write the desktop passwd file.
                         */
                    }
                    CSSSLogger.DbgLog(CSSSLogger.GetExecutionPath(this) + " Store is already persistent");
					CSSSLogger.DbgLog("StartPersistenceByDesktopPasswd - Started");
                    return true;
                }
				
            
                if(!File.Exists(GetPasscodeByDesktopFilePath()))
                {										
					if (File.Exists(GetPasscodeByMasterPasswdFilePath()))
					{
						// wait for the user to start the Persistence by entering MP
						return false;					
					}

                    //Else passcode needs to be generated.
                    baPasscode = CASACrypto.GenerateMasterPasscodeUsingString(
                                             desktopPasswd,
                                             GetPasscodeByDesktopFilePath(), 
                                             GetValidationFilePath(),
                                             user.UserIdentifier);

                    if( null == baPasscode )
                        return false;

                    if(!File.Exists(GetKeyFilePath()))
                    {
						GenerateAndStoreEncryptionKey(baPasscode);
						lss = new LocalStorage(this,baPasscode);
						bIsStorePersistent = true;
						return true;
                    }

                }
                baPasscode = CASACrypto.GetMasterPasscodeUsingDesktopPasswd(desktopPasswd, GetPasscodeByDesktopFilePath());
                if(baPasscode != null)
                {
                    if(CASACrypto.ValidatePasscode(baPasscode,GetValidationFilePath()))
                    {
                        lss = new LocalStorage(this,baPasscode);
                        bIsStorePersistent = true;
                        return true;
                    }
                    else
                    {
                        lss = null;
                        bIsStorePersistent = false; //till masterPasswd is verified
                    }
                    return true;
                }
                else
                {
                    CSSSLogger.DbgLog(CSSSLogger.GetExecutionPath(this) + " May be desktop passwd has changed");
                    lss = null;
                    bIsStorePersistent = false;
                    return false;
                }
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
            }
            return false;
        }

		internal bool GenerateAndStoreEncryptionKey(byte[] baPasscode)
		{
			RijndaelManaged myRijndael = new RijndaelManaged();
			byte[] key;
			byte[] IV = new byte[16];
			//Create a new key and initialization vector.
			try 
			{
				myRijndael.GenerateKey();
				key = myRijndael.Key;
			
				CASACrypto.StoreKeySetUsingMasterPasscode(key,IV, 
					baPasscode,
					GetKeyFilePath());
			}
			catch (Exception e)
			{
				return false;
			}
			return true;			
		}


        internal bool SetMasterPassword(string mPasswdFromIDK)
        {
            try
            {
                char[] trimChars = {'\0'};
                string mPasswd = mPasswdFromIDK.TrimEnd(trimChars);
                bool isVerifyOperation = false;
                string mPasswdFileName = GetPasscodeByMasterPasswdFilePath();
                byte[] baPasscode;
                if(File.Exists(mPasswdFileName))
                    isVerifyOperation = true; //else it is a set operation.

                string desktopPasswd = GetDesktopPasswd();
            
                if(isVerifyOperation == false)
                {
                    /* Here the master password file needs to be generated.
                     */
                    if(desktopPasswd != null)
                    {
                        baPasscode = CASACrypto.GetMasterPasscodeUsingDesktopPasswd(desktopPasswd, GetPasscodeByDesktopFilePath());
                        if(CASACrypto.ValidatePasscode(baPasscode,GetValidationFilePath()))
                        {
                            CASACrypto.EncryptAndStoreMasterPasscodeUsingString(
                                                                 baPasscode,
                                                                 mPasswd,
                                           GetPasscodeByMasterPasswdFilePath());
                            return true;
                        }
                        else
                        {
                            //Probably desktop passwd has changed.
                            //But as even master passwd is being set only now,
                            //the persistent store is lost.

                            baPasscode = CASACrypto.GenerateMasterPasscodeUsingString(mPasswd,GetPasscodeByMasterPasswdFilePath(),GetValidationFilePath(), user.UserIdentifier);
                            if(baPasscode != null)
                            {
                                CASACrypto.EncryptAndStoreMasterPasscodeUsingString(baPasscode,mPasswd,GetPasscodeByMasterPasswdFilePath());
                                CASACrypto.EncryptAndStoreMasterPasscodeUsingString(baPasscode,desktopPasswd,GetPasscodeByDesktopFilePath());
                                if(File.Exists(GetPersistenceFilePath()))
                                {
                                    File.Delete(GetPersistenceFilePath());
                                    CSSSLogger.DbgLog("Removing the persistent storeas its meaningless now.");
                                }
                                if( bIsStorePersistent == false )
                                { 
                                    lss = new LocalStorage(this,baPasscode);
                                    bIsStorePersistent = true;
                                }
                                return true;
                            }
                            else
                            {
                                return false;
                            }
                        }
                        //return true;
                    }//if a valid desktop Passwd is present - if ends here
                    else
                    {
                        /* If desktop passwd is not there and user sets
                         * master password.
                         */
                        if(File.Exists(GetPersistenceFilePath()))
                        {
                            File.Delete(GetPersistenceFilePath());
                            CSSSLogger.DbgLog("Removing the persistent storeas its meaningless now. - Desktop passwd is not there and Master password is being set");
                        }
                        if(File.Exists((GetPasscodeByDesktopFilePath())))
                        {
                            File.Delete((GetPasscodeByDesktopFilePath()));
                            CSSSLogger.DbgLog("Removing the persistent storeas its meaningless now. - Desktop passwd is not there and Master password is being set");
                        }
                

                        baPasscode = CASACrypto.GenerateMasterPasscodeUsingString(mPasswd,GetPasscodeByMasterPasswdFilePath(),GetValidationFilePath(), user.UserIdentifier);
                        if(baPasscode != null)
                        { 
							if(!File.Exists(GetKeyFilePath()))
							{
								GenerateAndStoreEncryptionKey(baPasscode);
							}

                            CASACrypto.EncryptAndStoreMasterPasscodeUsingString(baPasscode,mPasswd,GetPasscodeByMasterPasswdFilePath());
                            if( bIsStorePersistent == false )
                            {
                                lss = new LocalStorage(this,baPasscode);
                                bIsStorePersistent = true;
                            }
                            return true;
                        }
                        return false;
                    }
                }//end of isVerifyOperation == false
                else
                {
                    /* Verify the master password. If verified, and if
                     * persistence has not started, start it.
                     */

                    //Get the passcode from master passwd file and validate.
                    //If validation succeeds,start persistence.
                    if(desktopPasswd == null)
                    {
                        baPasscode = CASACrypto.DecryptMasterPasscodeUsingString(mPasswd, GetPasscodeByMasterPasswdFilePath());
                        if(CASACrypto.ValidatePasscode(baPasscode,GetValidationFilePath()))
                        {
                            if(bIsStorePersistent == false)
                            {
                                lss = new LocalStorage(this,baPasscode);
                                bIsStorePersistent = true;
                            }
                            return true;
                        }
                        else
                        {    
                            return false;
                        }
                    }
                    else
                    {  //There are 2 cases - either desktop passwd has changed
                       //or it hasnt.
                        baPasscode = CASACrypto.GetMasterPasscodeUsingMasterPasswd(mPasswd, GetPasscodeByMasterPasswdFilePath());
                        if(CASACrypto.ValidatePasscode(baPasscode,GetValidationFilePath()))
                        {
                            RewriteDesktopPasswdFile(baPasscode,desktopPasswd);
                            if(bIsStorePersistent == false)
                            {
                                lss = new LocalStorage(this,baPasscode);
                                bIsStorePersistent = true;
                            }
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }                          
                }
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
            }
            return false;
        }//End of SetMasterPassword

        internal bool RewriteDesktopPasswdFile(byte[] baPasscode, string desktopPasswd)
        {
            try
            {
                CASACrypto.EncryptAndStoreMasterPasscodeUsingString(baPasscode, desktopPasswd, GetPasscodeByDesktopFilePath());
                CSSSLogger.DbgLog("Re-encryted passcode with desktop passwd");
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
            }
            return true;
        }

        internal byte[] GetPasscodeFromOldDesktopPasswd(string oldDesktopPasswd)
        {
            try
            {
                byte[] baPasscode = CASACrypto.GetMasterPasscodeUsingDesktopPasswd(oldDesktopPasswd, GetPasscodeByDesktopFilePath());
                if(CASACrypto.ValidatePasscode(baPasscode,GetValidationFilePath()))
                {
                    return baPasscode;
                }
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
            }
            return null;
        } 

        /* This method would be called, when the user is setting his
         * master passcode for the first time.
         */

        internal bool SetMasterPasscode(string sMasterPasscode)
        {
            return true;    
#if false
            bool bRet = false;
            try
            {
                if(!CASACrypto.CheckIfMasterPasscodeIsAvailable(desktopPasswd, GetPasswdFilePath()))
                {
                    RijndaelManaged myRijndael = new RijndaelManaged();
                    byte[] key;
                    byte[] IV = new byte[16];
                    //Create a new key and initialization vector.
                    myRijndael.GenerateKey();
                    key = myRijndael.Key;
                    CASACrypto.StoreKeySetUsingMasterPasscode(key,IV,sMasterPasscode,GetKeyFilePath());
                    //Store the master passcode encrypted with the desktopPasswd
                    CASACrypto.EncryptAndStoreMasterPasscodeUsingString(sMasterPasscode, desktopPasswd, GetPasswdFilePath());
                    lss = new LocalStorage(this,sMasterPasscode);
                    bIsStorePersistent = true;
                    bRet = true;
                }
                else
                {
                    //Console.WriteLine("Master passcode is already set");
                }
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
            }
            return bRet;
#endif
        }

        internal void IncrRefCount()
        {
            try
            {
                ssMutex.WaitOne();
                refCount++;
                ssMutex.ReleaseMutex();
                CSSSLogger.DbgLog(CSSSLogger.GetExecutionPath(this) + " : RefCount = " + refCount);
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
                throw e;
            }
        }

        internal void DecrRefCount()
        {
            try
            {
                ssMutex.WaitOne();
                refCount--;
                ssMutex.ReleaseMutex();
                CSSSLogger.DbgLog(CSSSLogger.GetExecutionPath(this) + " : RefCount = " + refCount);
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
                throw e;
            }

        }

        internal bool AddKeyChain(KeyChain keychain)
        {
            try
            {
                keychain.CreatedTime = DateTime.Now;
                keyChainList.Add(keychain.GetKey(),keychain);
            }
            catch(Exception e)
            {
                 CSSSLogger.DbgLog(e.ToString());
                 throw e;
            }

            CSSSLogger.DbgLog(CSSSLogger.GetExecutionPath(this) + " - Succefully added Keychain = "+ keychain.GetKey() + " length = "+ (keychain.GetKey()).Length);

            return true;
        }
        internal bool RemoveKeyChain(string id)
        {
            keyChainList.Remove(id);
            return true;
        }

		internal KeyChain GetKeyChainDefault()
		{	
			return GetKeyChain("SSCS_SESSION_KEY_CHAIN_ID\0");
		}

        internal KeyChain GetKeyChain(string id)
        {
            if(keyChainList.ContainsKey(id))
            {
               CSSSLogger.DbgLog("In " + CSSSLogger.GetExecutionPath(this) + " Keychain already exists.");
               KeyChain kc = (KeyChain)(keyChainList[id]);
               kc.AccessedTime = DateTime.Now;
               return kc;
            }  
            else
            {
               CSSSLogger.DbgLog("In " + CSSSLogger.GetExecutionPath(this) + " Keychain doesnot exist.Returning null.");
                throw new KeyChainDoesNotExistException(id);
            }
        }
		
		internal bool CheckIfKeyChainExists(string id)
        {
            if(keyChainList.ContainsKey(id))
                return true;
            else
                return false;
        }


		internal void UpdatePersistentStore()
		{
			if (lss != null)
				lss.PersistStoreWithDelay();
		}

        /* This function would need to do any storage/cleanup required
         * before removing a user session.
         */
        internal bool CommitStore()
        {
            if(lss != null)
                lss.PersistStore();
            return true;
        }

        internal IEnumerator GetKeyChainEnumerator()
        {
           //TBD
           // Return an Enumerator class which has all secrets in this keychain
           return keyChainList.GetEnumerator();
        }
        internal void DumpSecretstore()
        {
            lock(keyChainList.SyncRoot)
            {
            IDictionaryEnumerator iter = (IDictionaryEnumerator)GetKeyChainEnumerator();
            while( iter.MoveNext() )   
            {
                int i = 0;
                KeyChain kc = (KeyChain)iter.Value;
                CSSSLogger.DbgLog("\nKeychain id = " + kc.GetKey());
                CSSSLogger.DbgLog("Secret List is ");
                IDictionaryEnumerator secIter = (IDictionaryEnumerator)(kc.GetAllSecrets());
                while(secIter.MoveNext())
                {
                    Secret secret = (Secret)secIter.Value;
                    CSSSLogger.DbgLog("Secret " + i.ToString() + " id = " + secret.GetKey() + " value = " + secret.GetValue() );
                    IDictionaryEnumerator etor = (IDictionaryEnumerator) secret.GetKeyValueEnumerator();
                    while(etor.MoveNext())
                    {
                        KeyValue kv = (KeyValue)etor.Value;
                        CSSSLogger.DbgLog("Key = " + kv.Key +" Value = " + kv.GetValue());
                    }
                    i++;    
                }
            }
            }
        }

        internal int GetSecretStoreState() 
        {
            return state;
        }
        internal int GetNumKeyChains()
        {
            return keyChainList.Count;
        }

        internal bool SetSecretStoreState(int stateToSet)
        {
           //BrainShare Special Only - Only Session keychains state 1
           
           state = STATE_OK;
           return true; 
        }

		internal bool ChangeMasterPassword(string sCurrentPWD, string sNewPWD)
		{
			string sMasterFilePath = GetPasscodeByMasterPasswdFilePath();
			byte[] baPasscode = CASACrypto.GetMasterPasscodeUsingMasterPasswd(sCurrentPWD, sMasterFilePath);
			if (baPasscode != null)
			{
				CASACrypto.EncryptAndStoreMasterPasscodeUsingString(baPasscode, sNewPWD, sMasterFilePath);
				return true;
			}
			return false;
		}

        internal string GetDesktopPasswd()
        { 
            try
            {
                string keyChainId = ConstStrings.SSCS_SESSION_KEY_CHAIN_ID + "\0";
                KeyChain keyChain = GetKeyChain(keyChainId);
                Secret secret = keyChain.GetSecret(ConstStrings.MICASA_DESKTOP_PASSWD);
                string passwd = secret.GetKeyValue(ConstStrings.MICASA_DESKTOP_PASSWD_KEYNAME).GetValue();
                return passwd;
            }
            catch(Exception e)
            {
                CSSSLogger.ExpLog(e.ToString());
            }
            return null;
        }

        internal string GetUserHomeDirectory()
        {
            return user.GetUserHomeDir();
        }

        internal string GetKeyFilePath()
        {
            string homeDir = GetUserHomeDirectory();
            return homeDir + ConstStrings.MICASA_KEY_FILE;
        }
        internal string GetPasscodeByDesktopFilePath()
        {
            string homeDir = GetUserHomeDirectory();
            return homeDir + ConstStrings.MICASA_PASSCODE_BY_DESKTOP_FILE;
        }

        internal string GetPasscodeByMasterPasswdFilePath()
        {
            string homeDir = GetUserHomeDirectory();
            return homeDir + ConstStrings.MICASA_PASSCODE_BY_MASTERPASSWD_FILE;
        }

        internal string GetPersistenceFilePath()
        {
            string homeDir = GetUserHomeDirectory();
            return homeDir + ConstStrings.MICASA_PERSISTENCE_FILE;
        }
        internal string GetValidationFilePath()
        {
            string homeDir = GetUserHomeDirectory();
            return homeDir + ConstStrings.MICASA_VALIDATION_FILE;
        }
    }
}