Description:A SYSTEM AND A METHOD FOR DIGITAL INHERITANCE

FIELD OF THE DISCLOSURE
[0001] This invention generally relates to a field of computer science engineering, and more particularly to a system and method for digital inheritance to protect user data during and after the user’s life.

BACKGROUND
[0002] The subject matter discussed in the background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the background section merely represents different approaches, which in and of themselves may also correspond to implementations of the claimed technology.
[0003] Every online app works with a user id and password which users create at the time of signup to create their account. From that point onwards, all their data is stored and maintained in their account. Users access the data, add and update, and in some apps, they are also able to connect and share the data with others.
[0004] Out of fear of losing their data, particularly the data of high value, many users create other backups. They store their login credentials on paper, in a spreadsheet or other physical and online mediums to ensure they do not lose it. They backup their data in a similar manner. Some users even share it with close family for safekeeping, who in turn also use similar mediums to store it. If the data comprises sensitive information about their assets, health, employment or business, the need for backup is even more because they need their family to have access to it in case there is an emergency in which the user cannot access it.
[0005] However, any backup mechanism is susceptible to error and oversight. One may change their login credentials in the app but not in their backup. Further, one may forget where the backup is. One’s backup itself may have leakage points for data loss and theft. One’s computer or device may get broken or stolen any time. One may decide against sharing their data with a family member, but it has already been shared. One usually finds this process tedious and repetitive when done periodically. This creates a tendency to defer.
[0006] In the digital world today, the users have no mechanism to ensure their sensitive data or information is automatically available to their family in case they are not around. This may happen for a temporary period or permanently depending upon the nature of the emergency they encounter in life. There have been cases where family members struggle for crucial information when their main breadwinner is not around anymore. Since data is a “soft asset” that could be the key to the user’s actual physical assets, not being aware of it or not being able to access it could be tragic for their well-being going forward.
[0007] According to a patent application “US9639940B2” titled “Imaging apparatus and methods for generating a guide display showing a photographing technique for approximating a composition of a subject image to that of a sample image” discloses about A display apparatus (which may be included in an imaging apparatus) includes: a display unit; a guide display generation circuit which acquires an image file including image data and photographing posture data including information of an inclination and a height of an imaging apparatus performing an imaging operation when the image data was created by the imaging operation to generate a photographing posture guide display based on the photographing posture data; and a display control circuit which causes the display unit to display an image based on the image data and the photographing posture guide display. A data processing apparatus may include a signal processing circuit which creates an image file including image data and photographing posture data.
[0008] According to another patent application “WO2022093318A1” titled “Systems and methods for digital impression and memorialization” discloses about a method for propagating a first user virtually via a digital legacy social media profile includes obtaining training data over an initial time period that includes user input data and/or accessed data relating. The method includes obtaining configuration settings from the first user, the configuration settings including at least one of a filter setting or one or more nominees. The method includes generating a digital legacy social media profile of the first user using the training data and the one or more configuration settings and launching the digital legacy social media profile on a server in response to an initiation. The method includes providing an option to present the digital legacy social media profile to at least a second user such that the digital legacy social media profile is accessible to the second user even when the digital legacy social media profile is inaccessible to the first user.
[0009] According to another patent application “US20170034182A1” titled “System and protocol for programmatic inheritance of digital assets” discloses an asset management system implements machine-based management and transfer of digital assets. The system enables creation and storage of digital assets, which can be accessed and/or modified by one or more authenticated users. The asset management system enables designation of one or more inheriting users to have access to the digital asset(s) in the event that a programmatic trigger condition is satisfied. In response to input from a user, the asset management system creates one or more programmatic trigger conditions with various inputs which must be satisfied in order for a digital asset transfer to take place. The asset management system defines one or more actions to take place upon a determination that the programmatic trigger condition(s) is satisfied. Permissions associated with the digital asset(s) can be modified to authorize one or more inheriting users to access the digital assets in a manner authorized by a primary user. A variety of other automated actions can be defined by the system to occur in association with execution of the digital asset transfer.
[0010] According to another patent application “CN115375503A” titled “Block chain-based social platform digital asset inheritance and will order customization method” discloses a block chain-based social platform digital asset inheritance and will order customization method, and belongs to the technical field of block chain application methods. The method comprises the steps that a user applies for establishing a digital asset will to a social platform, selects a inheritor according to personal wishes, establishes account association, and sets an externally open authority for social dynamic content, so that personalized will order and privacy protection are realized; building a succession contract code on the chain, and when a legal successor meets a trigger condition, automatically executing the contract and generating a succession log to be recorded on the chain; before the end of the life cycle of the user is determined, the on-chain testament can be changed again on the basis of the original testament according to the personal intention of the user; and the judicial institution or the government affair service institution supervises and examines the inherited affairs, and if the inherited affairs are abnormal, the mediation or the responsibility tracing are carried out according to legal intervention under the chain. The method is helpful for promoting the rationality and the legality of the digital assets in the social field as legacy inheritance, and is a beneficial supplement of digital inheritance.
[0011] Therefore, there is a need for an automatic system of digital inheritance to protect user information during and after the user’s life in which an inheritor assigned by the user automatically gets the access to user information.
OBJECTIVES OF THE INVENTION
[0012] The objective of present invention is to provide a system for digital inheritance.
[0013] Furthermore, the objective of present invention is to provide a method for digital inheritance.
[0014] Furthermore, the objective of present invention is to provide a system and method to assign an inheritor by a user to automatically get the access of the user’s data, when the user is unable to access their data due to any eventuality.
[0015] Furthermore, the objective of present invention is to provide an inheritance feature which a user can opt for at any stage by choosing their inheritor and the period of inactivity after which inheritance should trigger.
[0016] Furthermore, the objective of present invention is to change the inheritor or period of inactivity any time, or even reset the inheritance completely.
[0017] Furthermore, the objective of present invention is to provide an inheritance tree structure where data could be inherited through generations, in cases where the inheritors’ inheritance get triggered one after the other due to any eventuality occurring at any time.
[0018] Furthermore, the objective of present invention is to provide a system and method in which any inheritance that has been triggered is automatically terminated the moment the owner logs in again.
[0019] Furthermore, the objective of present invention is to check the inheritance flag where the user is the inheritor, and the inherited data of the immediate data owner and all preceding ones is fetched using a recursive mechanism.

SUMMARY
[0020] According to an aspect, the present embodiments disclose a system for digital inheritance. The system comprises a processor. Further, the system comprises a memory communicatively coupled to the processor via a network interface. Further, the memory is configured to store one or more instructions executed by the processor (104). The system further comprises a database. The database is configured to store at least one or more user’s data, inheritance data. The system further comprises a base module executing on the processor (104). The base module configured to cause the processor (104) to execute an account management module to create one or more user accounts based at least on the one or more user’s data and inheritance data. The account management module further generates one or more keys for the one or more user accounts. The base module further causes the processor (104) to execute a security module to encrypt and decrypt the generated one or more keys.
[0021] The base module further causes the processor (104) to execute an inheritance module to determine an inheritor and a period of inactivity after which inheritance should trigger. Further, the inheritance module creates an inheritance tree having the inheritor to cascade inheritance from the inheritor to other. Further, the inheritance module identifies the inheritor whose inheritance needs to be triggered and set an inheritance migration flag. Further, the inheritance module, in response to determining that the at least one trigger condition is satisfied and the inheritor is identified, authorize the inheritor to access the data of the one or more user accounts. The base module further causes the processor (104) to execute a notification module to send one or more notifications to the one or more user accounts and the inheritor.
[0022] Additionally, in the system, when one or more user accounts is logged in, the inheritance migration flag is checked whether the one or more user accounts is the inheritor and if it is set, the inheritance data of the one or more user accounts is fetched via a recursive mechanism.
[0023] Additionally, in the system, inheritance triggers automatically and connects from the inheritor to the next, in the inheritance tree, coupled with automatic trigger of un-inheritance, the moment one or more preceding user accounts anywhere in the inheritance tree is activated again, while the other inheritances in the same inheritance tree still remain valid.
[0024] In an embodiment, the one or more user’s data includes at least passwords, education details, financial data, insurance data, health records, business information, and work and family related data. In an embodiment, the inheritance data includes the inheritor, the period of inactivity and the inheritance tree. In another embodiment, the one or more keys include at least a login key, a vault key, a public-private key pair and a connect key.
[0025] In an embodiment, the inheritor, the period of inactivity and the inheritance tree is configured to get reset for the one or more user accounts. In another embodiment, if the one or more user accounts is logged in again, the inheritance migration flag is reset and the inheritor loses the access to the one or more user accounts.
[0026] In an another embodiment, the present invention also discloses a method for digital inheritance. The method comprises of creating one or more user accounts based at least on input provided, via a user interface, having one or more data to be inherited, a period of inactivity, an inheritor. Further, the method comprises of determining the inheritor of an inheritance tree from the inheritance data, via a recursive mechanism and the inheritor public key from the inheritance tree of the determined inheritor. Further, the method comprises generating one or more connect keys of the one or more user accounts to allow the inheritor to access the one or more data to be inherited. Further, the method comprises encrypting the one or more connect keys with the inheritor public key. The method further comprises storing the encrypted one or more connect keys in a database.
[0027] In an embodiment, one or more private keys of the one or more user accounts decrypts the encrypted one or more connect keys stored in the database (108), when the one or more user accounts is activated again.
[0028] In an embodiment, the method further comprises getting one or more data owner’s owner, via a recursive mechanism, from the inheritance tree, wherein the one or more data owner’s owner is the one or more user accounts. Further, the method comprises of checking if inheritance flag is set for the one or more data owner’s owner. The method further comprises, getting the one or more data to be inherited by the one or more data owner’s owner. Further, the method includes decrypting the one or more data to be inherited by one or more connect keys. Further, the method includes accessing the decrypted one or more data by the one or more user accounts.
[0029] In an embodiment, un-inheritance triggers automatically, the moment one or more preceding user accounts anywhere in the inheritance tree is activated again, while the other inheritances in the same inheritance tree still remain valid.

BRIEF DESCRIPTION OF THE DRAWINGS
[0030] The accompanying drawings illustrate various embodiments of systems, methods, and embodiments of various other aspects of the disclosure. Any person with ordinary skills in the art will appreciate that the illustrated element boundaries (e.g. boxes, groups of boxes, or other shapes) in the figures represent one example of the boundaries. It may be that in some examples one element may be designed as multiple elements or that multiple elements may be designed as one element. In some examples, an element shown as an internal component of one element may be implemented as an external component in another, and vice versa. Furthermore, elements may not be drawn to scale. Non-limiting and non-exhaustive descriptions are described with reference to the following drawings. The components in the figures are not necessarily to scale, emphasis instead being placed upon illustrating principles.
[0031] FIG. 1 illustrates a system (100) for digital inheritance, according to an embodiment of the present invention;
[0032] FIG. 2 illustrates a flow chart of a method (200) for digital inheritance, according to an embodiment of the present invention;
[0033] FIG. 3 illustrates a flow chart of checking inheritance flag (300) for digital inheritance, according to an embodiment of the present invention;
[0034] FIG. 4 illustrates a user interface (400) of the system (100), according to an embodiment of the present invention;
[0035] FIG. 5 illustrates a screenshot (500) of opting in for inheritance on the user interface (400) of the system (100), according to an embodiment of the present invention;
[0036] FIG. 6 illustrates another screenshot (600) of opting out of inheritance on the user interface (400) of the system (100), according to an embodiment of the present invention;
[0037] FIG. 7 illustrates another screenshot (700) of inherited account on the user interface (400) of the system (100), according to an embodiment of the present invention; and
[0038] FIG. 8 illustrates another screenshot (800) of a signup on the user interface (400) of the system (100), according to an embodiment of the present invention.
DETAILED DESCRIPTION
[0039] Some embodiments of this disclosure, illustrating all its features, will now be discussed in detail. The words “comprising,” “having,” “containing,” and “including,” and other forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms “a,” “an,” and “the” include plural references unless the context clearly dictates otherwise.
[0040] Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present disclosure, the preferred, systems and methods are now described. Embodiments of the present disclosure will be described more fully hereinafter with reference to the accompanying drawings in which like numerals represent like elements throughout the several figures, and in which example embodiments are shown. Embodiments of the claims may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. The examples set forth herein are non-limiting examples and are merely examples among other possible examples.
[0041] Online website and app users today have most of their data online. Their bank account ids and transactions, medical history, business information, employment details, property, mortgage and insurance documents, legal deeds and passwords to numerous websites and apps are all online and part of their digital life. These are their soft assets which hold the key to their actual assets and liabilities in life. Protection of such sensitive data is not merely a data security requirement in a website or app, but key to certainty of life for the user and their family. Digital inheritance is therefore a crucial value-add for billions of online users globally, across demography and geography to ensure data protection and availability.
[0042] The present invention discloses a system and a method for digital inheritance to protect user data during and after the user’s life. In the present invention, if a user is unable to access their data due to any eventuality, the “nominee” they have assigned as their “inheritor” automatically gets the access to their data. This follows a “tree structure” also known as “inheritance tree” where data could be inherited through generations, one after the other. As a result, it is never lost. Moreover, the system and the method completely eliminates the need for any backup mechanism. In all the embodiments, the terms “data” and “information” may have the same meaning. And, the terms “data” and “information” may be used in place of one another.
[0043] Every user can choose inheritance for their data, documents and files. All the data is protected for the user during and after their lifetime for their family’s well-being. This includes the data that the user may have connected with others, or vice versa.
[0044] In an embodiment of the present invention, FIG. 1 illustrates a system (100) for digital inheritance. The system (100) may comprise a computer having a user interface (102), a processor (104) directly coupled with a user interface (102) and a memory (106). Further, the computer is linked to a database (108), via a network interface (110). Further, the processor (104) may be coupled with a base module (112), via the network interface (110).
[0045] In an embodiment, the processor (104) may be coupled to different elements of the system (100), via the network interface (110). Further, the processor (104) may be responsible for performing the operations of the elements of the system (100), as described below in detail. Further, the processor (104) may be configured to process incoming requests from the user interface (102). Further, the processor (104) may interact with the elements based on the required operations. Further, the processor (104) may return the result back to the user interface (102) for display.
[0046] In an embodiment, the user interface (102) may include screens, forms and/or control to allow one or more users to manage their data. Further, the user interface (102) may be configured to assign an inheritor to one or more user accounts. Further, the user interface (102) may allow to configure the inheritance data. It should be noted that the inheritor may be another user having a user account. Further, it should be noted that a user can have only one inheritor (not more) for their data. The inheritor may, however inherit data of one or more users if all of them choose him/her as their inheritor.
[0047] Further, the system (100) may comprise the memory (106) communicatively coupled to the processor (104) via the network interface (110). Further, the memory (106) may be configured to store a set of instructions executed by the processor (104).
[0048] Further, the computer may be linked to the database (108). The database (108) may be configured to store at least one or more user’s data, inheritance data. In an embodiment, the inheritance data may include the inheritor, a period of inactivity and an inheritance tree, which is later described in the detailed description. Further, the database (108) may be configured to store one or more user accounts access permissions. In an embodiment, a datasheet may be created by one or more user accounts, having the one or more user’s data. The database (108) may further be configured to store the datasheet. For example, a user account may create a datasheet titled “Citibank” and add all Citibank-related data and files in multiple posts over a period of time. This datasheet may further be stored in the database (108) to access later.
[0049] In an exemplary embodiment, the database (108) may be a database selected from the group of database including, but not limited to structured query language (SQL) server database, MySQL, Oracle, PostgreSQL, MongoDB, Redis, Elasticsearch, Cassandra, MariaDB, IBM Db2.
[0050] In an embodiment, the network interface (110) may be configured to facilitate a communication link among the components of the system (100). It can be noted that the network interface (110) may be a wired network and/or a wireless network. The network interface (110), if wireless, may be implemented using one or more communication techniques. The one or more communication techniques may be Visible Light Communication (VLC), Worldwide Interoperability for Microwave Access (WiMAX), Long Term Evolution (LTE), Wireless Local Area Network (WLAN), Infrared (IR) communication, Public Switched Telephone Network (PSTN), Radio waves, and other communication techniques, known in the art.
[0051] Further, the system (100) may comprise the base module (112) communicatively coupled to the processor (104) and the memory (106) via the network interface (110). In one embodiment, the base module (112) may be configured to manage at least the one or more user accounts, one or more user’s data, the inheritor, inheritance data. In one embodiment, the base module (112) may act as a central module to receive and send instructions to each of the plurality of modules. In one embodiment, the base module (112) may be configured to activate and/or deactivate a plurality of sub-modules according to the information received from the processor (104) and the memory (106).
[0052] Further, the base module (112) may comprise an account management module (114). The account management module (114) may be configured to create and manage one or more user accounts based at least on input provided, via the user interface (102). The input may comprise of the one or more user’s data. Further, the one or more user’s data may include at least passwords, education details, financial data, insurance data, health records, business information, and work and family related data. Further, the account management module (114) may be configured to generate one or more keys based on the one or more user accounts. Further, the one or more keys may include at least a login key, a vault key, a public-private key pair, one or more connect key. In one embodiment, inheritance may connect data between the one or more user accounts and the inheritor, via the generated one or more keys.
[0053] In an embodiment, users may sign up to make one or more user accounts with the login key and a personal riddle that comprises of a riddle question and riddle answer. The login key, the riddle question and the riddle answer are stored encrypted in the database (108). The login key is self-encrypted. The riddle question is encrypted with login key. The riddle answer is self-encrypted.
[0054] In an example embodiment, if a user’s login key is “james-bond”, it is encrypted with “james-bond”. Thereafter, unless the user enters “james-bond” in the next login, the login key cannot be decrypted. Similarly, for the riddle answer.
[0055] Further, on signup, the account management module (114) may generate the vault key and the public-private key pair for every user. The vault key may be a system-generated as a combination of the user’s signup timestamp, login key and a 32-character cryptography random string and stored in the database (108). The vault key may be encrypted with the user’s login key and the riddle answer. Further, the public-private key may be a system-generated 1024 RSA keys. Further, the private key is encrypted with the vault key and stored in the database (108).
[0056] For user data thereafter, the one or more connect keys may be generated for every datasheet the user creates. The one or more connect keys may be system-generated as a combination of the user’s current timestamp, login key and riddle answer. This is done for every new datasheet the user creates. Further, the one or more connect keys are encrypted with the user’s public key and stored in the database (108). As a result, every datasheet has a unique connect key. Further, when a datasheet is connected between two users, it is encrypted with their respective public keys. Further, when a user logs in, their private key then decrypts their own data and connected datasheets thereof.
[0057] In an example embodiment, a “datasheet” may be a list of posts and files a user adds over time in a given page. For example, a user may create a datasheet titled “Citibank” and add all Citibank-related data and files in multiple posts over a period of time.
[0058] Further, the base module (112) may comprise a security module (116). The security module (116) may be configured to encrypt and decrypt the generated one or more keys for data security. Further, the security module (116) may be configured to ensure security and privacy of the one or more user accounts. Further, the security module (116) may comprise security protocol to protect data from unauthorized access and/or breaches.
[0059] Further, the base module (112) may comprise an inheritance module (118). The inheritance module (118) may be configured to determine the inheritor. The inheritance module (118) may further be configured to determine a period of inactivity after which inheritance should trigger. The period of inactivity may be the number of days the one or more user accounts is not accessed. Further, the inheritance module (118) may be configured to create an inheritance tree having the inheritor to cascade inheritance from the inheritor to other. Further, the inheritance module (118) may be configured to define at least one trigger condition to determine that inheritance should occur. Further, the inheritance module (118) may be configured to identify the inheritor whose inheritance needs to be triggered and set an inheritance migration flag. Further, in response to determining that the at least one trigger condition is satisfied and the inheritor is identified, the inheritor module may authorize the inheritor to access the data of the one or more user accounts.
[0060] In an embodiment, when one or more user accounts is logged in, the inheritance migration flag is checked whether the one or more user accounts is the inheritor. And if it is set, the inherited data of the one or more user accounts is fetched using a recursive mechanism. It may be possible that an intermediate account in the inheritance tree structure may not be triggered for inheritance. Therefore, inheritance may return only those accounts in the inheritance tree structure in which the inheritance migration flag is set. In another embodiment, if the one or more user accounts is logged in again, the inheritance migration flag may be reset and the inheritor loses the access to the one or more user accounts.
[0061] In an example embodiment, a daughter may inherit her mother account, but not her grandmother’s account whose inheritor is her mother and her grandmother is still active. But if her grandmother too becomes inactive in future, the daughter will inherit her grandmother’s data too.
[0062] In an embodiment, the one or more user may be authorized to access the data and the inheritor may not be authorized to access the data, unless the inheritance is triggered.
[0063] Further, the base module (112) may comprise a notification module (120). Further, the notification module (120) may be configured to send one or more notifications to the one or more user accounts and the inheritor. Further, the notification module (120) may inform one or more user accounts about the status of their data. Further, the notification module (120) may be configured to alert the inheritor about their access rights. Further, the notification module (120) may be configured to provide updates on any changes or events related to the inheritance.
[0064] In an embodiment, inheritance triggers automatically and connects from the inheritor to the next, in the inheritance tree. Further, automatic trigger of inheritance is coupled with automatic trigger of un-inheritance. Further, the automatic trigger of un-inheritance may happen the moment the one or more user accounts anywhere in the inheritance tree is logged in again. Further, during the automatic trigger of un-inheritance, the other inheritances in the same inheritance tree may still remain valid, except those preceding the un-inherited account in the tree since the now logged-in user is their actual inheritor.
[0065] In an embodiment, at any time, the one or more user accounts may reset at least the inheritance of the data, the period of inactivity and the inheritor.
[0066] FIG. 2 illustrates a flow chart of a method (200) for digital inheritance, according to an embodiment. The flow chart of a method (200) for digital inheritance further helps to understand the working of the system (100) for digital inheritance. The method (200) for digital inheritance as depicted in the flow chart may be described in a stepwise manner as follows. In this regard, each block may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that in some alternative implementations, the functions noted in the blocks may occur out of the order noted in the drawings. For example, two blocks are shown in succession in FIG. 2 may be executed substantially concurrently or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. Any process descriptions or blocks in flowcharts should be understood as representing modules, segments, or portions of code that include one or more executable instructions for implementing specific logical functions or steps in the process, and alternate implementations are included within the scope of the example embodiments in which functions may be executed out of order from that shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved. In addition, the process descriptions or blocks in flow charts should be understood as representing decisions made by a hardware structure such as a state machine. The flowchart starts at the step (202) and proceeds till step (210). FIG. 2 is described in conjunction with FIG. 1 and FIG. 3.
[0067] At first, creating one or more user accounts based at least on input provided, via a user interface (102), having one or more data to be inherited, a period of inactivity, an inheritor, at step 202. In an embodiment, a login key and riddle may be used to sign up for creating one or more user account. In one embodiment, the one or more data may include at least passwords, education details, financial data, insurance data, health records, business information, and work and family related data. In an embodiment, a “datasheet” may be a list of data, documents and files, the user adds over time.
[0068] For example, a user may create a user account, via the account management module (114), having the financial details of Citibank-related data. Further, a datasheet titled “Citibank” may be created, and all Citibank-related data and files in multiple posts are added over a period of time. And the period of inactivity is set to be 90 days.
[0069] Successively, determining the inheritor of an inheritance tree from the inheritance data, via a recursive mechanism and the inheritor public key from the inheritance tree of the determined inheritor, at step 204. In one embodiment, the inheritor’s inheritor may be obtained via the inheritance module (118). In one embodiment, the public key may be generated via the account management module (114). In an embodiment, when the datasheet may be connected between two users, it is encrypted with their respective public keys.
[0070] For example, the inheritance module (118) further gets the inheritor “user2” to inherit the “Citibank” datasheet. And, the public key of the “user2” is obtained from the inheritance tree.
[0071] Successively, generating one or more connect keys of the one or more user accounts to allow the inheritor to access the one or more data to be inherited, at step 206. In an embodiment, the one or more connect keys may be generated for the one or more data. The one or more connect keys may be system-generated as a combination of the user’s current timestamp, login key and riddle answer. This may be done for every new datasheet the user creates.
[0072] For example, a connect key is generated via the account management module (114) for the datasheet “Citibank”. Thus, the datasheet “Citibank” has a unique connect key. The connect key is encrypted with the public key.
[0073] Successively, encrypting the one or more connect keys with the inheritor public key, at step 208. In an embodiment, when the datasheet is connected between two users, it may be encrypted with their respective public keys. As a result, every datasheet has a unique connect key. In an embodiment, new user data may also be added. In another embodiment, a data connected data by another user may also be added. Further, the new user data and the data connected another data by another user may also have their own one or more connect keys that may further be encrypted.
[0074] For example, the connect keys of the data of the user are encrypted for security purpose with the public key of the “user2”.
[0075] Successively, storing the encrypted one or more connect keys in a database (108), at step 210. In an embodiment, the database (108) may be a database selected from the group of database including, but not limited to structured query language (SQL) server database, MySQL, Oracle, PostgreSQL, MongoDB, Redis, Elasticsearch, Cassandra, MariaDB, IBM Db2.
[0076] For example, after encrypting the connect keys of the user, the encrypted keys are stored in the database (108) to access them later.
[0077] Referring to FIG. 3, when the one or more user accounts is logged in, an inheritance migration flag may be checked.
[0078] Further, the inheritance migration flag may be checked by getting one or more data owner’s owner, via a recursive mechanism, from the inheritance tree, wherein the one or more data owner’s owner is the one or more user accounts, at step 302. For example, the one or more data owner’s owner is the user whose user account is created with the datasheet “Citibank”. The data owner is the “user2”.
[0079] Successively, checking if inheritance flag is set for the one or more data owner’s owner, at step 304. For example, the inheritance flag is checked for the user account when the “user2” account logs in.
[0080] Successively, getting the one or more data to be inherited by the one or more data owner’s owner, at step 306. In an embodiment, the inheritance may trigger after getting the one or more data. For example, if the inheritance flag is set, the data to be inherited of the data owner is obtained so as to trigger inheritance.
[0081] Successively, decrypting the one or more data to be inherited by one or more connect keys, at step 308. For example, after obtaining the one or more data to be inherited, the one or more data is decrypted by one or more connect keys.
[0082] Successively, accessing the decrypted one or more data by the one or more user accounts, at step 310. For example, after decrypting the data, the “user2” is able to access and view the data.
[0083] In the method (200), un-inheritance triggers automatically, the moment the one or more user accounts anywhere in the inheritance tree is logged in again, while the other inheritances in the same inheritance tree still remain valid, except those preceding the logged-in user who now becomes the inheritor of such preceding accounts.
[0084] In the method (200), un-inheritance triggers automatically, the moment one or more preceding user accounts anywhere in the inheritance tree is activated again, while the other inheritances in the same inheritance tree still remain valid.
[0085] In an exemplary embodiment, FIG. 4 illustrates an interface of the system (100). Further, on signup and subsequent logins, users may be displayed their account dashboard. Further, the users may be prompted to store sensitive data, such as passwords, education details, financial data, insurance data, health records, business information, and work and family related data. Further, the users may also have the option to add a new category. The “inheritance” feature may be displayed alongside, which the user can opt for at any stage. Further, the user may choose their inheritor and the period of inactivity after which inheritance should trigger.
[0086] In an exemplary embodiment, FIG. 5 illustrates a screenshot of opting in for inheritance (500) in the system (100). In an embodiment, the only pre-requisite for inheritance may be that the user must first create their unique share handle. This is because inheritance connects inherited data between two users using the system-generated one or more keys. For creating inheritance, the minimum inactivity days may be stipulated as 1. Further, the user may choose their inheritance inactivity days as any number. Next, the user may simply enter the share handle of the inheritor. Further, the user may simply click on save inheritance (502) to save the created inheritance of all currently existing data, new data created henceforth and the data connected by other users now or in the future.
[0087] In an exemplary embodiment, FIG. 6 illustrates another screenshot of opting out of inheritance (600) in the system (100). In an embodiment, at any time, the user may reset inheritance of their data. Further, they may also change the inactive days and/or the inheritor. Further, the inheritance data of a user and the “reset” option (602) are shown in FIG. 6. Further, if the user does not want any inheritance, they may simply “turn it off” permanently or not set it in the first place.
[0088] In an exemplary embodiment, FIG. 7 illustrates an inherited account (702) on the interface (700) of the system (100). In an embodiment, inheritance, once set, may be triggered whenever a user account becomes inactive. Further, the inheritance may never get triggered if the user is active. Further, the inheritance may be triggered repeatedly over time as and when the user faces an eventuality and is incapacitated in some manner that the user is unable to access their data. Further, when triggered, the inheritor may see the inherited account (702) on the dashboard
[0089] In an exemplary embodiment, FIG. 8 illustrates a signup page (800) on the interface of the system (100). In one embodiment, the signup page may comprise of private key (802), riddle question and answer (804). The private key (802) may also be referred to as “login key”. Further, the private key (802), riddle question and answer (804) may be stored encrypted in the database (108).
[0090] In an embodiment, in the present invention, important user data is meant to be accessible to their family members during emergencies, assuming the user chooses a family member as inheritor. Also, the inheritance tree ensures data flow through generations in the user’s family.
[0091] In an embodiment, the present invention may be a progressive web app (PWA). The PWA may be an app that's built using web platform technologies, but that provides a user experience like that of a platform-specific app. The PWA may be installed on a device. The PWA may integrate with the device. The PWA may further integrate with other applications installed on the device.
[0092] In an embodiment, the present invention may provide a good user experience even when the device has intermittent network connectivity. Further, the present invention may perform operations in the background, even when the main app is not running.
[0093] In an embodiment, in the present invention, all changes the inherited data by the inheritor may occur in the name of the original data owner to ensure the inheritance is temporary only.
[0094] In an embodiment, at no given time, the data of the one or more user accounts may be seen by the inheritor, if the inheritance has not been triggered.
[0095] In an embodiment, the system (100) and the method (200) may be totally user-controlled and user-driven to ensure the user have full control over their sensitive data.
[0096] It should be noted that the system (100) and the method (200) in any case could undergo numerous modifications and variants, all of which are covered by the same innovative concept; moreover, all of the details can be replaced by technically equivalent elements. In practice, the components used, as well as the numbers, shapes, and sizes of the components can be whatever according to the technical requirements. The scope of protection of the invention is therefore defined by the attached claims.
, C , Claims:1. A system (100) for digital inheritance, comprising:
a processor (104);
a memory (106) communicatively coupled to the processor (104) via a network interface (110), configured to store one or more instructions executed by the processor;
a database (108) configured to store at least one or more user’s data and inheritance data;
a base module (112) executing on the processor (104) and configured to cause the processor (104) to execute:
an account management module (114) to:
create one or more user accounts based at least on the one or more user’s data and inheritance data, and
generate one or more keys for the one or more user accounts;
a security module (116), configured to encrypt and decrypt the generated one or more keys;
an inheritance module (118), to:
determine an inheritor and a period of inactivity after which inheritance should trigger;
create an inheritance tree having the inheritor to cascade inheritance from the inheritor to other;
identify the inheritor whose inheritance needs to be triggered and set an inheritance migration flag; and
in response to determining that the at least one trigger condition is satisfied and the inheritor is identified, authorize the inheritor to access the data of the one or more user accounts;
a notification module (120), to send one or more notifications to the one or more user accounts and the inheritor;
wherein when one or more user accounts is logged in, the inheritance migration flag is checked whether the one or more user accounts is the inheritor and if it is set, the inheritance data of the one or more user accounts is fetched via a recursive mechanism; and
wherein inheritance triggers automatically and connects from the inheritor to the next, in the inheritance tree, coupled with automatic trigger of un-inheritance, the moment one or more preceding user accounts anywhere in the inheritance tree is activated again, while the other inheritances in the same inheritance tree still remain valid.
2. The system (100) as claimed in claim 1, wherein the one or more user’s data includes at least passwords, education details, financial data, insurance data, health records, business information, and work and family related data.
3. The system (100) as claimed in claim 1, wherein the inheritance data includes the inheritor, the period of inactivity and the inheritance tree.
4. The system (100) as claimed in claim 1, wherein the one or more keys include at least a login key, a vault key, a public-private key pair and a connect key.
5. The system (100) as claimed in claim 1, wherein the inheritor, the period of inactivity and the inheritance tree is configured to get reset for the one or more user accounts.
6. The system (100) as claimed in claim 1, wherein if the one or more user accounts is logged in again, the inheritance migration flag is reset and the inheritor loses the access to the one or more user accounts.
7. A method for digital inheritance, comprising:
creating one or more user accounts based at least on input provided, via a user interface (102), having one or more data to be inherited, a period of inactivity, an inheritor, at step 202;
determining the inheritor of an inheritance tree from the inheritance data, via a recursive mechanism and the inheritor public key from the inheritance tree of the determined inheritor, at step 204;
generating one or more connect keys of the one or more user accounts to allow the inheritor to access the one or more data to be inherited, at step 206;
encrypting the one or more connect keys with the inheritor public key, at step 208; and
storing the encrypted one or more connect keys in a database (108), at step 210.
8. The method as claimed in claim 7, wherein one or more private keys of the one or more user accounts decrypts the encrypted one or more connect keys stored in the database (108), when the one or more user accounts is activated again.
9. The method as claimed in claim 7, further comprises:
getting one or more data owner’s owner, via a recursive mechanism, from the inheritance tree, wherein the one or more data owner’s owner is the one or more user accounts, at step 302;
checking if inheritance flag is set for the one or more data owner’s owner, at step 304;
getting the one or more data to be inherited by the one or more data owner’s owner, at step 306;
decrypting the one or more data to be inherited by one or more connect keys, at step 308; and
accessing the decrypted one or more data by the one or more user accounts, at step 310.
10. The method as claimed in claim 6, wherein un-inheritance triggers automatically, the moment one or more preceding user accounts anywhere in the inheritance tree is activated again, while the other inheritances in the same inheritance tree still remain valid.