Obviously, this is not possible with Namecoin as it is (and straight-forward lookups). But it would be possible to implement a scheme like this based on Namecoin as it is, but with a custom lookup procedure. It could work like this:
- To claim ownership of the namespace, I register a name like "ns/domob".
- Every day, I choose a secret nonce value N_i (for day i). I also update "ns/domob" to reveal the last day's value N_(i-1).
- To register a name "domob/name" at day i, I would compute hash(N_i | name) and register that on the Namecoin network instead. Since only I know N_i in cleartext on day i, noone else can register names in that scheme. (And it is very unlikely that the name would already be taken.)
- After N_i has been revealed on day i+1, everyone can redo the computation to look up "domob/name". They know for sure that only I could have registered the name, since I revealed the nonce through "ns/domob".
This registration is "slow" in the sense that names can only be looked up after revealing the used nonce, so they take a day (or whatever time interval is chosen) to be accessible publicly. Also the lookup is not straight-forward, as different nonce values have to be tried.
This can be optimised by having a "tree structure", though - there could be nonces that are updated daily, monthly and yearly. The yearly nonces are tried first, which is quick as there are only a few. If the name is not found, only the monthly nonces since the last revealed yearly one are tried, and then the daily ones in the same manner. That way, each name registration is actually reflected in three names on the Namecoin network - but each lookup only needs to try at most 50 or so name lookups (which is fine when done locally at least).
Does that sound like a reasonable protocol? Or does anyone else have ideas for how to do "owned namespaces" in a more efficient / simpler form?