When you register a domain like example.com, you gain administrative control over the DNS records for that domain and its subdomains. However, this doesn't mean you "own" subdomains in a legal sense - they exist within your domain's namespace.

Subdomains are created through DNS records. Here's how you can create one programmatically using AWS Route 53's API:

const AWS = require('aws-sdk');
const route53 = new AWS.Route53();

const params = {
  ChangeBatch: {
    Changes: [
      {
        Action: 'CREATE',
        ResourceRecordSet: {
          Name: 'blog.example.com',
          Type: 'CNAME',
          TTL: 300,
          ResourceRecords: [
            {
              Value: 'example.com'
            }
          ]
        }
      }
    ]
  },
  HostedZoneId: 'YOUR_HOSTED_ZONE_ID'
};

route53.changeResourceRecordSets(params, function(err, data) {
  if (err) console.log(err, err.stack);
  else console.log(data);
});

As mentioned in the .name registry agreement, some TLDs have special rules:

• .name domains require personal identifiers
• .edu domains have strict eligibility requirements
• .gov domains are restricted to government entities

To protect your domain, consider these technical measures:

# Wildcard DNS record to prevent others from using your subdomains
*.example.com. 3600 IN A 192.0.2.1

# Web server configuration to catch-all subdomains
server {
    listen 80;
    server_name ~^(.*)\.example\.com$;
    return 403;
}

While you technically control the DNS namespace, trademark law may come into play if someone registers a confusingly similar domain at a higher level (e.g., example.co) and creates subdomains that infringe on your brand.

Here's a Python script to monitor your subdomains:

import dns.resolver

def check_subdomains(domain, subdomains):
    results = {}
    for sub in subdomains:
        try:
            answers = dns.resolver.resolve(f"{sub}.{domain}", 'A')
            results[sub] = [str(r) for r in answers]
        except:
            results[sub] = None
    return results

print(check_subdomains("example.com", ["www", "mail", "blog"]))

When you register a domain like example.com, you gain administrative control over the DNS records for that domain and all its potential subdomains. This means:

• You can create unlimited subdomains (mail.example.com, blog.example.com)
• You control the DNS resolution for these subdomains
• No one can register these as separate domains with registrars

Here's how DNS zone files typically handle subdomains:

; Zone file for example.com
$ORIGIN example.com.
@       IN  SOA  ns1.example.com. admin.example.com. (
                 2023081501 ; serial
                 3600       ; refresh
                 900        ; retry
                 604800     ; expire
                 86400 )    ; minimum TTL

; Main domain records
@       IN  NS     ns1.example.com.
@       IN  A      192.0.2.1
www     IN  CNAME  @

; Subdomain examples
mail    IN  A      192.0.2.10
blog    IN  A      192.0.2.20
api     IN  A      192.0.2.30

The .name TLD operates differently due to its specific registration policies:

# Python example checking .name eligibility
def validate_name_domain(domain):
    parts = domain.split('.')
    if len(parts) != 3 or parts[-1] != 'name':
        return False
    first, last = parts[0], parts[1]
    # Must represent a real individual's name
    return bool(first) and bool(last) and not last.isdigit()
    
print(validate_name_domain('john.doe.name'))  # True
print(validate_name_domain('doe.name'))       # False

When developing applications that handle domains:

// JavaScript domain validation
function isSubdomainOf(domain, parentDomain) {
  return domain.endsWith(.${parentDomain}) || 
         domain === parentDomain;
}

// Example usage:
console.log(isSubdomainOf('mail.example.com', 'example.com')); // true
console.log(isSubdomainOf('example.org', 'example.com'));      // false

Important security considerations include:

• Wildcard certificates (*.example.com) cover all subdomains
• Subdomain takeover risks if DNS records point to abandoned services
• Cookie scoping considerations (domain vs. subdomain)

# Bash script to check subdomain vulnerabilities
#!/bin/bash
domain="example.com"
subdomains=("dev" "test" "staging")

for sub in "${subdomains[@]}"; do
  host "${sub}.${domain}" || 
    echo "Warning: ${sub}.${domain} may be vulnerable to takeover"
done

While most TLDs follow standard rules, exceptions include: