view release on metacpan or  search on metacpan

examples/05-api-keys.pl  view on Meta::CPAN

        $suffix = 'RO';
    } elsif ($key_type eq 'admin') {
        $key_part = $auth->gen_random_token(32, 'url_safe');
        $suffix = 'ADM';
    } elsif ($key_type eq 'webhook') {
        $key_part = $auth->gen_random_token(24, 'alphanumeric');
        $suffix = 'WHK';
    } else {  # standard
        $key_part = $auth->gen_random_token(24, 'url_safe');
        $suffix = 'STD';
    }
    
    my $api_key = "${user_prefix}_${app_prefix}_${timestamp}_${key_part}_${suffix}";
    
    return {
        key         => $api_key,
        username    => $username,
        app_name    => $app_name,
        key_type    => $key_type,
        permissions => $permissions || [],
        created_at  => time(),
        last_used   => undef
    };
}

sub extract_key_info {
    my ($api_key) = @_;
    
    # Parse the structured key format
    if ($api_key =~ /^([A-Z]{3})_([A-Z]{3})_([0-9a-fA-F]{8})_([A-Za-z0-9_-]+)_([A-Z]{2,3})$/) {
        my ($user_prefix, $app_prefix, $timestamp, $key_part, $suffix) = ($1, $2, $3, $4, $5);
        
        my %type_map = (
            'RO'  => 'readonly',
            'ADM' => 'admin', 
            'WHK' => 'webhook',
            'STD' => 'standard'
        );
        
        return {
            user_prefix => $user_prefix,
            app_prefix  => $app_prefix,
            timestamp   => hex($timestamp),
            key_part    => $key_part,
            key_type    => $type_map{$suffix} || 'unknown',
            created_at  => hex($timestamp)
        };
    }
    
    return;
}

print "--- API Key Generation ---\n";

# Generate keys for different users and applications
my @key_specs = (
    ['alice',   'webapp',     'standard', ['read', 'write']],
    ['alice',   'mobile',     'readonly', ['read']],
    ['bob',     'dashboard',  'admin',    ['read', 'write', 'delete', 'admin']],
    ['charlie', 'webhook',    'webhook',  ['webhook']],
    ['alice',   'backup',     'readonly', ['read', 'export']]
);

my @generated_keys;

for my $spec (@key_specs) {
    my ($username, $app, $type, $perms) = @$spec;
    my $key_info = generate_api_key($username, $app, $type, $perms);
    push @generated_keys, $key_info;
    
    printf "%-8s/%-10s (%s): %s\n",
           $username, $app, $type, $key_info->{key};
}

print "\n--- Key Information Extraction ---\n";

for my $key_info (@generated_keys) {
    my $extracted = extract_key_info($key_info->{key});
    
    if ($extracted) {
        printf "Key: %s...\n", substr($key_info->{key}, 0, 20);
        printf "  User prefix: %s | App prefix: %s | Type: %s\n",
               $extracted->{user_prefix}, $extracted->{app_prefix}, $extracted->{key_type};
        printf "  Created: %s\n", scalar localtime($extracted->{created_at});
    }
    print "\n";
}

print "--- Key Type Examples ---\n";

# Demonstrate different key types and their characteristics
my %key_types = (
    'readonly' => {
        desc => 'Read-only access, safe for client-side use',
        perms => ['read', 'list', 'export'],
        length => 'medium'
    },
    'standard' => {
        desc => 'Standard API access for most applications', 
        perms => ['read', 'write', 'update'],
        length => 'medium'
    },
    'admin' => {
        desc => 'Full administrative access',
        perms => ['read', 'write', 'delete', 'admin', 'user_management'],
        length => 'long'
    },
    'webhook' => {
        desc => 'Webhook validation and callbacks',
        perms => ['webhook', 'callback', 'event_receive'],
        length => 'medium'
    }
);

for my $type (sort keys %key_types) {
    my $info = $key_types{$type};
    my $sample_key = generate_api_key('demo', 'example', $type, $info->{perms});
    
    printf "%-10s: %s\n", uc($type), $info->{desc};
    printf "%-10s  Key: %s\n", '', $sample_key->{key};
    printf "%-10s  Permissions: %s\n", '', join(', ', @{$info->{perms}});