How can information be recovered after it has been overwritten (single pass) by a secure deletion program?

We know that information can be retreived after it has been deleted. There are several tools for file “undeletion” (Recuva, FTK, some tools contained in Caine, etc.)

I have heard as well, that data can be recovered, even after it has been rewritten. For this exact reason, the DoD used to approve methods which included (DoD 5220.22-M) to 7 (DoD 5220.22-ECE) overwrite passes. This is still a low bar, considering there are algorithms which include 35 passes (Gurmann).

Why, though? What papers, articles, or use cases have been published that suggest successful data recovery after single or dual pass of overwritting data?

Which software, methods, or tools allow me to analyze a given HDD for “further layers” (?) of recovery or overwriting?

(I know there is a different approach and dynamic to SSD, so for the time being, let’s not meddle into it)

Outlook events bullk deletion using MS Flows

My requirement is delete all events from outlook using MS Flows.

I have tried with below mentioned steps.

select –> Outlook 365 –> add, update or modified Outlook events –> select calendar –> Calendar –> ID __> in Id place i have provided Subject name(It might be wrong)

if condition yes –> delete event v2 no–> Notification

But no luck

How do you encourage deletion of something without putting the user off?

Scenario: A manager has access to her team members data on an internal system. She also has access to certain team members that have since moved to another role or under another manager.

We want the managers to keep their employee roster up to date so it would be helpful if these managers “deleted” people they no longer are responsible for.

Through testing I received feedback that this remove feature was ignored because they don’t want to mess up the database. The problem is the database is a mess because we have duplicates and crossed wires, so we need the managers to use this remove feature. So my question is how can I improve this component to actively encourage data cleansing?

enter image description here

Parallel deletion and traversal in a lock free linked list

I’m unsure about the safety of deletion in a linked list. I’ve seen the issue posed by a parallel insertion and deletion (resulting in the loss of the insertion) and proposed solutions to that problem. That makes perfect sense. However, nowhere have I seen it mentioned that an unlucky traversal in parallel with a deletion can cause problems. For example, if we have the linked list:

A -----> B -----> C* ------> D 

and one process (process 1) is traversing it, currently pointing at C (as indicated by the *), however before process 1 reads the next pointer of C, another process (process 2) deletes C and frees its memory. Then, when the process 1 attempts to read C’s next pointer, it will be reading uninitialized memory (which could be used to store an int for example), and thus could be pointed to an invalid location, and cause a segmentation fault by dereferencing that pointer.

How can this issue be avoided?

Alert on file deletion activities – what are the specifics?

From the Microsoft Docs

Unusual activities (by user) These detections identify users who perform:

Unusual multiple file download activities Unusual file share activities Unusual file deletion activities Unusual impersonated activities Unusual administrative activities 

These policies look for activities within a single session with respect to the baseline learned, which could indicate on a breach attempt. These detections leverage a machine learning algorithm that profiles the users log on pattern and reduces false positives. These detections are part of the heuristic anomaly detection engine that profiles your environment and triggers alerts with respect to a baseline that was learned on your organization’s activity.

Can someone please advise if this alert is editable in order to set your own preference or it is as described?

Is there a way to set up an alert at tenancy level to be alerted whenever a file is deleted or a site is deleted?

External Content Type Connection : illegal operation attempted on a registry key marked for deletion

when I add a connection to a sql server database in an external content type from Sharepoint Designer 2013 I get this error:

Retrieving the COM class factory for component with CLSID {BDEADDF26....} failed due to the following error: 800703fa illegal operation attempted on a registry key that has been marked for deletion 

I see that CLSID corresponds to

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\ISAPI\OWSSVR.DLL

What’s wrong?

Non-recursive version of Trie deletion

So,I was looking for the non-recursive version of Trie data structures deletion in the internet. I couldn’t find one. The best I could manage to find was a recursive implementation of trie in this website. Looking at the code for sometime, I thought that I could make the recursive version of the deletion to non-recursive one. Here is my take on it. Remember, I am worried whether I have done effective memory cleanup. Any insight on the overall code structure will also be helpful. Thanks.

#include<iostream> using namespace std; struct node{     bool isWord=false;     node* previous;     node* children[27]; };  void insert(node*& root, string key){     node *temp = root;     temp->previous = NULL;     int keyLen = key.length();     for(int i=0; i<keyLen; ++i){         int index = key[i]-'a';         //If i is the last element         if(i==keyLen-1){             //then take notice of it             //and change isWord to true             temp->isWord=true;             temp->children[index] = NULL;         }         //If there is no node at a given index         if(!temp->children[index]){             //Form a new node             temp->children[index] = new node;             //Take notice of the node that it is coming from             (temp->children[index])->previous = temp;         }         //Traverse along the children node         temp = temp->children[index];     } }   bool search(node*&root, string key){     node*temp = root;     int keyLen = key.length();     for(int i=0; i<keyLen; ++i){         int index = key[i] -'a';         //If i is at string length         //and the end the end it finds         //itself to be true         if(i==keyLen-1 && temp->isWord==true)         {             return true;         }          //If a character does not exist         //in the traversal          if(!temp->children[index]){             return false;         }         temp = temp->children[index];     }     //If the string is longer then expected     return false; } bool hasNoChildren(node* root){     for(int i=0; i<27; ++i){         //If the root has at least one child         //then return false         if(root->children[i])return false;     }     //else return true     return true; } void remove(node*& root, string key){     if(!search(root,key)) return ;     node*temp = root;     int keyLen = key.length();     for(int i=0; i<keyLen; ++i){         int index = key[i]-'a';         /*If i reaches the length of the string         temp is turned to false is turned to false         Which means if day word 'foo' is part of longer         word 'football', 'foo' does not exist as a         seperate word.         And if only 'foo' exist in the dictionary,         it also signals for it get removed in the next         for loop.*/         if(i==keyLen-1){             temp->isWord = false;         }         temp = temp->children[index];     }      /*The pointer temp in the above for loop     manages to reach to the end of the string     Since, the previous pointer is being tracked     it is easy to retract , if it is so required.*/     for(int i=keyLen-1; i>=0; --i){          /*If the temp isWord variable is false          and it happens to have not children         then it is being removed. Not this removal         happens in the bottom up fashion, which         allows effective memory deletion.*/         if(temp->isWord == false && hasNoChildren(temp)){             node*p = temp;             temp = temp->previous;             delete p;             }             else temp= temp->previous;         } }   int main(){     node* a = new node;     string keys[] = { "the", "a", "there",                       "answer", "any", "by",                       "bye", "their", "hero", "heroplane" };     for (int i = 0; i < 10; i++)         insert(a, keys[i]);     search(a, "the") ? cout << "Yes\n" : cout << "No\n";     search(a, "these") ? cout << "Yes\n" : cout << "No\n";     remove(a,"heroplane");     search(a, "hero") ? cout << "Yes\n" : cout << "No\n";     return 0; }