File Coverage

blib/lib/Plack/Middleware/Auth/OAuth.pm

Criterion	Covered	Total	%
statement	52	54	96.3
branch	19	26	73.0
condition	10	14	71.4
subroutine	11	11	100.0
pod	2	4	50.0
total	94	109	86.2

package Plack::Middleware::Auth::OAuth;
use strict;
use warnings;
our $VERSION = '0.06';

use parent qw(Plack::Middleware);

use Plack::Request;
use Plack::Util::Accessor qw(
    consumer_key
    consumer_secret
    validate_post
    check_timestamp_cb
    check_nonce_cb
    unauthorized_cb
    validate_only
    secret_resolver_cb
    strict
);

use OAuth::Lite::Util qw(parse_auth_header);
use OAuth::Lite::ServerUtil;

sub prepare_app {
    my $self = shift;

    if (!$self->secret_resolver_cb) {
        die 'requires consumer_key'    unless $self->consumer_key;
        die 'requires consumer_secret' unless $self->consumer_secret;
    }

    for my $cb_method (qw/check_nonce_cb check_timestamp_cb unauthorized_cb secret_resolver_cb/) {
        if ($self->$cb_method && ref $self->$cb_method ne 'CODE') {
            die "$cb_method should be a code reference";
        }
    }

}

sub call {
    my ($self, $env) = @_;

    return ($self->validate($env) || $self->validate_only) ? $self->app->($env) : $self->unauthorized($env);
}

sub validate {
    my ($self, $env) = @_;

    my $auth = $env->{HTTP_AUTHORIZATION} or return;

    my ($realm, $params) = parse_auth_header($auth);
    $env->{'psgix.oauth_realm'}  = $realm;
    $env->{'psgix.oauth_params'} = $params;

    my $consumer_secret = $self->consumer_secret;
    if ($self->secret_resolver_cb) {
        $consumer_secret = $self->secret_resolver_cb->($params->{oauth_consumer_key}, $env);
    }
    else {
        return unless $params->{oauth_consumer_key} eq $self->consumer_key;
    }

    return if $self->check_timestamp_cb && !$self->check_timestamp_cb->($params);
    return if $self->check_nonce_cb && !$self->check_nonce_cb->($params);

    my $req = Plack::Request->new($env);
    my $req_params
        = $self->validate_post ? $req->parameters : $req->query_parameters;
    for my $k ($req_params->keys) {
        $params->{$k} = [$req_params->get_all($k)];
    }

    my $util = OAuth::Lite::ServerUtil->new(strict => $self->strict || 0);
    $util->support_signature_method($params->{oauth_signature_method});
    return unless $util->validate_params($params);

    $env->{'psgix.oauth_authorized'} = $util->verify_signature(
        method          => $req->method,
        url             => $req->uri,
        params          => $params,
        consumer_secret => $consumer_secret,
        token_secret    => $params->{oauth_token_secret},
    );
}

sub unauthorized {
    my ($self, $env) = @_;

    if ($self->unauthorized_cb) {
        $self->unauthorized_cb->($env);
    }
    else {
        my $body = 'Authorization required';
        return [
            401,
            [
                'Content-Type'    => 'text/plain',
                'Content-Lentgth' => length $body,
            ],
            [$body],
        ];
    }
}
1;
__END__