//rename this method since we do more than just Source or Sinks here
        private static void updateSourceOrSinkRule(O2RulePack o2RulePack,IDictionary<string, List<IO2Rule>> indexedO2Rules, string ruleSignature, string languageDBId, TraceType traceType)
        {
            if (indexedO2Rules != null && ruleSignature != null)
            {
                //bool createNotMappedRule = false;
                var createRuleWithType = O2RuleType.NotMapped;
                // only proccess Sources, Sinks and Lost Sinks
                if (traceType == TraceType.Source || traceType == TraceType.Known_Sink || traceType == TraceType.Lost_Sink)
                {
                    O2RuleType o2NewRuleType = O2RulePackUtils.getO2RuleTypeFromRuleType(traceType);
                    createRuleWithType = o2NewRuleType;

             /*       if (indexedO2Rules != null && false == string.IsNullOrEmpty(ruleSignature))
                        if (indexedO2Rules.ContainsKey(ruleSignature))
                        {
                            bool thereIsAlreadyARuleWithTheSameRuleType = false;
                            foreach (var o2Rule in indexedO2Rules[ruleSignature])
                            {
                                if (o2Rule.RuleType == O2RuleType.NotMapped)
                                // if it is not mapped change it to o2NewRuleType
                                {
                                    o2Rule.RuleType = o2NewRuleType;
                                    return;
                                }
                                if (o2Rule.RuleType == o2NewRuleType)
                                    // if it is already a rule of type o2NewRuleType, mark it so we can ignore it below
                                    thereIsAlreadyARuleWithTheSameRuleType = true;
                            }
                            if (false == thereIsAlreadyARuleWithTheSameRuleType)
                            // if we got this far, create a new rule of o2NewRuleType                                        
                            {
                                var newRule = O2RulePackUtils.createRule(o2NewRuleType, ruleSignature, languageDBId);
                                indexedO2Rules[ruleSignature].Add(newRule);
                                // add it to the index so that we don't have to calculate it again
                                o2RulePack.o2Rules.Add(newRule);
                            }
                        }
                    */
                }
                bool createNewRule = true;
                IO2Rule notMappedRule = null;

                if (indexedO2Rules.ContainsKey(ruleSignature))
                {
                    foreach (var o2Rule in indexedO2Rules[ruleSignature])
                    {
                        if (o2Rule.RuleType == createRuleWithType)          // dont create if there is already a rule of this type
                        {
                            o2Rule.Tagged = true;
                            createNewRule = false;
                        }
                        if (o2Rule.RuleType == O2RuleType.NotMapped)
                            notMappedRule = o2Rule;
                    }
                }
                // handle the case where we have already added a signature but it is not a NotMapped one
                if (createRuleWithType == O2RuleType.NotMapped &&  createNewRule && notMappedRule == null && indexedO2Rules.ContainsKey(ruleSignature))
                    createNewRule = false;

                // if required, Create  rule
                if (createNewRule)
                {
                    var vulnType = "O2.FindingRule." + createRuleWithType.ToString();
                    var newRule = new O2Rule(createRuleWithType,vulnType, ruleSignature, languageDBId,true);
                    o2RulePack.O2Rules.Add(newRule);
                    if (false == indexedO2Rules.ContainsKey(ruleSignature))
                        indexedO2Rules.Add(ruleSignature, new List<IO2Rule>());
                    indexedO2Rules[ruleSignature].Add(newRule);
                    if (notMappedRule != null)
                        indexedO2Rules[ruleSignature].Remove(notMappedRule);
                }
            }
        }
 internal static IO2Rule cloneRule(IO2Rule o2RuleToClone)
 {
     var clonedRule = new O2Rule
                          {
                              Comments = o2RuleToClone.Comments,
                              DbId = o2RuleToClone.DbId,
                              FromArgs = o2RuleToClone.FromArgs,
                              Param = o2RuleToClone.Param,
                              Return = o2RuleToClone.Return,
                              FromDb = o2RuleToClone.FromDb,
                              RuleType = o2RuleToClone.RuleType,
                              Severity = o2RuleToClone.Severity,
                              Signature = o2RuleToClone.Signature,
                              Tagged = o2RuleToClone.Tagged,
                              ToArgs = o2RuleToClone.ToArgs,
                              VulnType = o2RuleToClone.VulnType                                                                          
                          };
     return clonedRule;
 }
 public static O2Rule createRule(O2RuleType rtRuleType, String sSignature, String sDbID)
 {            
     var rRule = new O2Rule
                     {
                         Severity = "Medium",
                         DbId = sDbID,
                         Signature = sSignature,
                         RuleType = rtRuleType,
                         VulnType = String.Format("_O2.{0}", rtRuleType)
                     };
     return rRule;
 }
        private void addCirFunctionsAsRules(
            List<ICirFunction> cirFunctionsToProcess, bool keepRulesLoadedFromDatabase, 
            bool bAddExternalMethodsAsSourcesAndSinks,bool bAddInternalMethodsWithNoCallersAsCallbacks,
            bool bDontMarkAsCallbackOrSinksMethodsWithNoParameters,
            bool bdontAddIfRuleSignatureAlreadyExists, bool bDontAddIfThereAreNoCallersAndCallees,
            string newRulesVulnType)
        {            
            // for performance reasons run this on a separade thread
            O2Thread.mtaThread(
                () =>
                    {
                        // before adding more rules, clear the current list (the return null is to force the Sync version  of invokeOnThread )
                        this.invokeOnThread(()=>
                                                {
                                                    clearChangedRulesList();
                                                    return "done";
                                                });
                        
                        var newCallbackSignature = "O2.AutoMapping";
                        DI.log.info("adding {0} cirFunctions as rules", cirFunctionsToProcess.Count);

                        // get rules that we will keep (if there are rules loaded from Db and keepRulesLoadedFromDatabase is set)
                        var newO2Rules = (keepRulesLoadedFromDatabase)
                                             ? O2RulePackUtils.getRulesThatAreFromDB(currentO2RulePack)
                                             : new List<IO2Rule>();

                        //update index
                        indexedCurrentO2Rules = IndexedO2Rules.indexAll(newO2Rules);

                        if (keepRulesLoadedFromDatabase)
                            foreach (var o2Rule in newO2Rules)
                                o2Rule.Tagged = false;

                        var currentDatabaseID = MiscUtils_OunceV6.getIdForSuportedLanguage(currentLanguage).ToString();

                        var listOfChangedRules = new List<IO2Rule>();
                        var functionsToProcess = cirFunctionsToProcess.Count;
                        var functionsProcessed = 0;
                        foreach (var cirFunction in cirFunctionsToProcess)
                        {
                            var functionSignature = new FilteredSignature(cirFunction).sSignature;                            
                            // first check if there are any callers or callees on this function
                            //bDontAddIfThereAreNoCallersAndCallees
                            if (bDontAddIfThereAreNoCallersAndCallees && cirFunction.FunctionIsCalledBy.Count == 0 &&
                                cirFunction.FunctionsCalledUniqueList.Count == 0)
                            {
                                // don't add
                            }
                            else 
                                // then check if this already exists on the database
                                if (bdontAddIfRuleSignatureAlreadyExists &&
                                     indexedCurrentO2Rules.ContainsKey(functionSignature))
                                {
                                    foreach (var o2Rule in indexedCurrentO2Rules[functionSignature])
                                        o2Rule.Tagged = true;
                                }
                                // if not, then we will need ot create a new rule for this function
                                else
                                {                                    
                                    bool addAsNotMappedRule = false;
                                    //var functionSignature = new FilteredSignature(cirFunction).sSignature;

                                    // handle special cases 


                                    //bAddInternalMethodsWithNoCallersAsCallbacks (or the function is explicitly marked with cirFunction.IsTainted
                                    if (cirFunction.IsTainted || 
                                        (bAddInternalMethodsWithNoCallersAsCallbacks && cirFunction.HasControlFlowGraph && cirFunction.FunctionIsCalledBy.Count == 0))
                                    {
                                        //bDontMarkAsCallbackMethodsWithNoParameters
                                        if (false == bDontMarkAsCallbackOrSinksMethodsWithNoParameters ||
                                            cirFunction.FunctionSignature.IndexOf("()") == - 1)
                                            //cirFunction.FunctionParameters.Count > 0)  // can't use this since it is not 100% reliable
                                        {
                                            var newCallback = new O2Rule(O2RuleType.Callback,
                                                                         newCallbackSignature + ".Callback",
                                                                         functionSignature, currentDatabaseID, true);
                                            listOfChangedRules.Add(newCallback);
                                            newO2Rules.Add(newCallback);
                                        }
                                        else
                                            addAsNotMappedRule = true;
                                    }
                                    //bAddExternalMethodsAsSourcesAndSinks  - function calls nobody but it is called by others
                                    else if (bAddExternalMethodsAsSourcesAndSinks &&
                                             cirFunction.FunctionsCalledUniqueList.Count == 0 &&
                                             cirFunction.FunctionIsCalledBy.Count > 0)
                                    {
                                        // when importing CirData created by Core on Java, there is a bug that causes the ReturnType NOT to be populated 
                                        // this is why we use the cirFunction.FunctionSignature.IndexOf(":void") > -1 below instead of the more correct if (string.IsNullOrEmpty(cirFunction.ReturnType))
                                        //if (string.IsNullOrEmpty(cirFunction.ReturnType))
                                        //    DI.log.info("Method had empty cirFunction.ReturnType: {0}", cirFunction.FunctionSignature);
                                        // Only add source if the return parameter is not void
                                        if (!(cirFunction.FunctionSignature.IndexOf(":void") > -1 || cirFunction.ReturnType == "void" || cirFunction.ReturnType == "System.Void"))
                                        {
                                            var newSource = new O2Rule(O2RuleType.Source,
                                                                       newCallbackSignature + ".Source",
                                                                       functionSignature, currentDatabaseID, true);
                                            listOfChangedRules.Add(newSource);
                                            newO2Rules.Add(newSource);
                                        }
                                        else
                                            DI.log.info("Method Not marked as Source: {0}", cirFunction.FunctionSignature);
                                        // for sinks check for bDontMarkAsCallbackOrSinksMethodsWithNoParameters
                                        if (false == bDontMarkAsCallbackOrSinksMethodsWithNoParameters ||
                                            cirFunction.FunctionSignature.IndexOf("()") == -1)
                                            //cirFunction.FunctionParameters.Count > 0)
                                        {

                                            var newSink = new O2Rule(O2RuleType.Sink, newCallbackSignature + ".Sink",
                                                                     functionSignature, currentDatabaseID, true);
                                            listOfChangedRules.Add(newSink);
                                            newO2Rules.Add(newSink);
                                        }
                                        //else                                            
                                        //    DI.log.info("Method Not marked as Sink: ", cirFunction.FunctionSignature);
                                    }
                                    else
                                    {
                                        addAsNotMappedRule = true;
                                    }

                                    if (addAsNotMappedRule)
                                    {
                                        // add as NotMapped
                                        var newO2Rule = new O2Rule(newRulesVulnType, functionSignature, currentDatabaseID) { Tagged = true };
                                        newO2Rules.Add(newO2Rule);
                                    }
                                }
                            // Counter
                            if ((functionsProcessed++)%200 == 0)
                                DI.log.info("In addCirFunctionsAsRules: {0} / {1} cir Functions processed",
                                            functionsProcessed, functionsToProcess);
                        }

                        // make the current rule pack the one with the rules we have just loaded
                            DI.log.info("{0} rules created", newO2Rules.Count);
                            var newRulePack = new O2RulePack("Rule Pack", newO2Rules);
                        setCurrentRulePack(newRulePack);

                        // we need to back to the GUI thread for the updates
                        this.invokeOnThread(
                            () =>
                                {
                                    // hide this ListView for performance reasons
                                    lvChangedRules.Visible = false;
                                    dgvRules.Visible = false;
                                    // add rules
                                    addRulesToChangedRulesList_BatchMode(listOfChangedRules);

                                  //  foreach (var changedO2Rule in listOfChangedRules)
                                  //      addRuleToChangedRulesList(changedO2Rule, false /*checkIfRuleIsAlreadyInList*/);
                                    
                                    // if we are in view all mode changed it to OnlyTaggedRules
                                    if (rbViewMode_AllRules.Checked)
                                        rbViewMode_OnlyTaggedRules.Checked = true;
                                    else
                                        setRulesViewMode(); // trigger refresh

                                    // now that all rules have been added make it visible again
                                    lvChangedRules.Visible = true;
                                    dgvRules.Visible = true;
                                });                                                                        
                    });
        }
 public static IO2Rule createASRule(string ruleSignature, string ruleTaintFrom, string ruleTaintTo)
 {
     var o2Rule = new O2Rule();
     o2Rule.DbId = "2";
     o2Rule.Signature = ruleSignature;
     o2Rule.FromArgs = ruleTaintFrom;
     o2Rule.ToArgs = ruleTaintTo;
     if (o2Rule.ToArgs == "none")
         o2Rule.RuleType = O2RuleType.DontPropagateTaint;
     else
         o2Rule.RuleType = O2RuleType.PropageTaint;
     if (o2Rule.ToArgs.IndexOf(".*") > -1)
     {
         o2Rule.Return = "1";
         o2Rule.ToArgs = o2Rule.ToArgs.Replace(".*", "");
     }
     else
         o2Rule.Return = "0";
     o2Rule.VulnType = "Summary Driven Rule";
     return o2Rule;
 }
 private void newRule()
 {
     var newO2Rule = new O2Rule();
     newO2Rule.Signature = "new rule";
     if (dgvRules.SelectedRows.Count > 0)
         foreach (DataGridViewRow selectedRow in dgvRules.SelectedRows)               // we have to do this because dgvRules.SelectedRows.Clear() doesn't work
             selectedRow.Selected = false;
     var newRuleRow = addO2RuleToDataGridView(newO2Rule);
     currentO2RulePack.O2Rules.Add(newO2Rule);
     newRuleRow.Selected = true;
     openRulesEditor();
 }