Turing complete policies | Ethereum Foundation Blog

One of the major security challenges of the Internet over the past 20 years has been the fairly simple problem of securing user accounts. Currently, users have accounts with hundreds of websites and dozens of passwords, resulting in… big Preparation to Superhero As individual websites, often run by people who are not particularly skilled in the finer points of encryption and Internet security, find themselves exploited by increasingly savvy hackers, users often deal with the complexity of remembering hundreds of passwords before either Make it simple or Make them all the same – With often Unfortunate results. Over time, a range of custom solutions have certainly evolved, including using your email account as a global backup, and “password manager” software such as Lastpass, although at a higher cost: such solutions either retain much of the basic complexity of Password access or giving centralized companies very high degrees of control over your online life.

There are many invitations to Gets get rid of to passwordsBut the question is: What do we replace them with? There are many ideas, from “one password to rule them all” to smartphone authentication to specialized hardware, biometrics, and all sorts of multi-factor M-of-N policies, but even these most complex constructions to date have typically been application-specific: giving you many Banks now have a specialized access device to log in to your bank account, but if you trust its security you can’t also use it to access your email. Overall, we see that the problem of how to best manage user access control and reduce key loss and theft risks is complex enough that it will never be solved “once and for all,” and therefore the best way to solve it is to allow a free market for solutions to flourish and allow each user to choose solutions. Which suits him best; However, the way to actually achieve this is through… Disassembly The “access control solutions” market comes from the “services” market. That means pretty much exactly what we are no Do it now.

How can we do that? The first step is to make some good use of the final abstraction: Turing complete code. Instead of allowing users, at the protocol level, to specify a password, provide a pre-defined set of service providers, or even a standard based on talking to a server of the user’s choice, allowing access policies to be defined in code implemented in a deterministic virtual machine (where it is An EVM is as good a start as any other virtual machine). The code can include digital signature verifications using any Encryption algorithm (so you get forward compatibility with quantum secure encryption for free), likely including keys on the user’s computer, and directly derived keys From the passwordor keys on a device or any arbitrary policy including any combination of the above. In this way, innovation in access control mechanisms can occur Without any need For websites (or other systems that require authentication) to do anything to accommodate new changes. In addition, the system allows precision Organizations To use the scheme with multi-person access controls right away, without the need for further integration.

The next step is code based on the complete Turing process. For many applications, you want the ability to let some users perform some operations but not others; For example, you may want to authorize your system administrator to change the IP address that a domain name points to, but you do not want to sell the entire domain. To accommodate this, the abstraction must be changed. A simple “Turing complete code as signature” setup might have the following form:

VM(code, server-provided nonce ++ signature) ?= 1

where Virtual machine It is a virtual machine that runs the code, takes the number provided by the server and the signature as input, and checks to see if the output is 1 or not. A simple example of code What can be put in place is an elliptic curve digital signature verification tool. To allow for different licensing requirements depending on the process, you’ll want to:

VM(code, server-provided nonce ++ operation_data ++ signature) ?= 1

A signature must be provided with every operation the user wants to perform (this has the benefit of providing specific evidence that can be verified by a third party that the operation has been authorized); Process data (imagine function name and arguments encoded in a ABI similar to Ethereum) will be added as an argument to the virtual machine, and the signature must be above both the number and the operation data.

This gets you quite far, but in some cases not far enough. A simple example is the following: What if you want to give someone permission to withdraw small amounts of money but not large amounts, for example. Limit withdrawal? In this case, the problem you have to overcome is simple: what if someone who is restricted to a maximum withdrawal limit of $100 tries to evade it by simply running a $90 withdrawal script over and over again? To solve this problem, you need a smarter withdrawal limit; Basically, something like “max $100 per day”. Another normal case is key revocation: If the key is compromised or lost, you want to replace it, and you want to make sure the world finds out that your policy has changed so attackers can’t try to impersonate you under your old policy.

To get over this last hump, we need to go one step further: we need to rely on the complete Turing process nation Policies; This means that processes must be able to change the state of the policy. This is where not only cryptography comes into play, but blockchains specifically. Of course, you could have a central server running the whole thing, and many people are perfectly fine with trusting a central server, but Blockchain is considered to be of moderate value Here because it is more convenient, provides a credible, neutral story, and is easier to standardize. Ultimately, since it would be very detrimental to innovation to permanently choose “one blockchain to rule them all,” the thing we want to standardize is a mechanism through which users can download modules to support it. any Blockchain or centralized solution as they like.

For blockchain-based applications, having a formal policy that is applied directly to the blockchain makes sense; There is no need to involve another special category of intermediaries, and people can start doing so now. The abstraction of “computation” offered by Ethereum makes it very easy to work with this approach: if your application works with simple users holding private keys, it also works with all kinds of individual, multi-party, device-dependent, and military personnel. score or any other policy that users will come up with in the future.

For other applications, users may want privacy, whether in their state changes or even in the nature of their policy at any given time. For this reason, you’ll likely want a solution like hookwhere blockchain technology still ensures the security of the process, but thanks to the wonders of knowledge-free technology, He knows nothing about what is secured; Before implementing Hook, simpler forms of encryption such as ring signatures may be sufficient.

Other applications

Account security is the first and most basic application of the code-as-policy concept, and there are others as well. A simple one is to register a domain name. Onename, a popular “decentralized name registration” service, is currently planning to implement a feature where top-level domains can choose fee policies for subdomains based on the number of letters, consonants, and vowels. This is useful, but of course economically ugly: there are certainly hundreds of characteristics other than letters, consonants and vowels that can affect the price of a domain name, and people may want to try other registration strategies such as Different types of auctions.

Again, the best solution is to implement some simple modules: letting people create their own namespace in Turing complete code. If you’re doing this on a platform where stateful Turing-complete code exists, you can just let an address control a subdomain, and then, you’re already supporting stateful Turing-complete domain policies. This is the essence of object-oriented programming: expose an interface, and let other objects, which can have arbitrarily complex internal code, satisfy that interface.

Another one is private equity trading. Especially in the case of private companies, stock trading is not and cannot be completely free and unrestricted as in cryptocurrency trading; Companies often want to impose restrictions such as:

• Giving shares to employees and not allowing them to sell them until after a period of time
• Requiring new shareholders to be approved by existing shareholders, with these approvals potentially coming with a cap on the number of shares that particular owner can own
• Forced purchase procedures
• Restricting the maximum rate at which shares can be sold (i.e. withdrawal limits), requiring waiting periods, or providing a right of first refusal to other shareholders.

Sure, you can create a blockchain-based private equity trading platform for one client, and provide the constraints that client wants. But what if other customers want different restrictions? You can also nip the problem in the bud, at least at the “core application layer,” and solve it once and for all by… allowing each individual stock, represented as a sub-currency, to have Represents restrictions As a Turing complete code.

This functionality can be represented in the “token” API by extending it, for example, as follows:

• Obtain the minimum balance (account): Get the minimum balance the account can currently hold
• Get the maximum balance (account): Get the maximum balance the account can currently hold

In short, applications have no policies; Applications interact with Things (user accounts, currencies, etc.), and objects have policies. Alternatively, even shorter:

Are you building a blockchain-based financial derivatives application, and someone asks you to add a feature to allow voting between multiple data feed providers instead of just one? Don’t even think about it; Instead, just assign a single feeder address, and let users set their own policies; The upside is that whatever code they use or write, they will be able to use it to provide more secure data feeds for decentralized arbitration as well. Are you building a DNS system, and someone is asking you to provide support for specific subdomain auction types? Don’t do this at the root DNS level; Instead, allow subdomains to be addresses, and allow users to create their own auction algorithms; Whatever algorithms they invent, they will be able to use them in their registration of decentralized chat usernames as well.

This is the benefit of abstraction: account security policy design can become an independent field of study in its own right, and any new solutions found can be immediately applied everywhere. Some people may want to trust a third party; Others will want a multi-signature license between five of their different devices, and some will want a key for themselves with the option of three of five friends coming together to reassign the key to a new device. Some will want an access policy where, if they don’t make any transactions within twelve months, they are presumed dead and the attorney will have access so they can execute on their will – vs. everyone of their digital assets. Some will want a policy that gives one full key to control applications that are declared low security, but two of the three keys for applications that are declared high security. The design of a name registration pricing policy can also become self-contained – as can a policy for restricting ownership of digital assets, an area that may be of interest to everyone from small and large traditional companies to community-based DAOs. This is the power of a Turing-complete code.