JSON-WebEncryption

 view release on metacpan or  search on metacpan

lib/JSON/WebEncryption.pm  view on Meta::CPAN

# -----------------------------------------------------------------------------

sub new {
    my($caller, %arg) = @_;

    my $self =  bless {}, $caller;

    $self->{alg}         = $arg{alg};
    $self->{enc}         = $arg{enc};
    $self->{key}         = $arg{key};
    $self->{private_key} = $arg{private_key};
    $self->{public_key}  = $arg{public_key};

    return $self;
}

# -----------------------------------------------------------------------------

sub encode_from_hash {
    my ($self, $hash) = @_;

lib/JSON/WebEncryption.pm  view on Meta::CPAN

    my $cipher     = _getCipher( $cipherType, $CEK, $padding, $iv, $keysize );
    my $ciphertext = $cipher->encrypt( $plaintext );

    return ($ciphertext, $encrypted_key);
}

# -----------------------------------------------------------------------------

sub _alg_RSA1_5_decode
{
    my ( $self, $enc_params, $private_key, $iv, $ciphertext, $encrypted_key  ) = @_;

    $private_key //= $self->{private_key};

    my $cipherType = $enc_params->[0];
    my $keysize    = $enc_params->[1] / 8; # /8 to get it in bytes
    my $padding    = $crypt_padding_map{ $enc_params->[3] };

    # Decrypt the encryption key using the Private Key
    my $rsa = Crypt::OpenSSL::RSA->new_private_key( $private_key ); # Key passed in is a Private Key
    $rsa->use_pkcs1_oaep_padding;
    my $CEK = $rsa->decrypt( $encrypted_key );

    # Use the encryption key to decrypt the message
    my $cipher = _getCipher( $cipherType, $CEK, $padding, $iv, $keysize );

    return  $cipher->decrypt( $ciphertext );
}

# -----------------------------------------------------------------------------

t/00_test_one.t  view on Meta::CPAN

use warnings;
use t::Util;

use Crypt::Rijndael;

use Test::More tests => 4;
use Test::Requires 'Crypt::OpenSSL::RSA';

my $secret      = Crypt::CBC->random_bytes( 16 );
my $rsa         = Crypt::OpenSSL::RSA->generate_key(1024);
my $private_key = $rsa->get_private_key_string;
my $public_key  = $rsa->get_public_key_string;

my $rsa2         = Crypt::OpenSSL::RSA->generate_key(1024);
my $private_key2 = $rsa2->get_private_key_string;
my $public_key2  = $rsa2->get_public_key_string;

# plaintext encoding public_key private_key secret algorithm extra_headers
test_encode_decode(
    desc  => 'RSA1_5 / A128CBC-HS256',
    input => {
        plaintext   => 'Hello World',
        private_key => $private_key,
        public_key  => $public_key,
        algorithm   => 'RSA1_5',
        encoding    => 'A128CBC-HS256'
    },
);

test_encode_decode(
    desc  => 'dir / A128CBC-HS256',
    input => {
        plaintext   => 'Hello World',
        secret      => $secret,
        algorithm   => 'dir',
        encoding    => 'A128CBC-HS256'
    },
);

test_encode_decode_object(
    desc  => 'RSA1_5 / A128CBC-HS256 => Object',
    input => {
        plaintext   => 'Hello World',
        private_key => $private_key,
        public_key  => $public_key,
        algorithm   => 'RSA1_5',
        encoding    => 'A128CBC-HS256'
    },
);

test_encode_decode_object(
    desc  => 'dir / A128CBC-HS256 => Object',
    input => {
        plaintext   => 'Hello World',

t/Util.pm  view on Meta::CPAN

use JSON::WebEncryption;

our @EXPORT = qw(test_encode_decode test_encode_decode_object);

sub test_encode_decode {
    my %specs = @_;
    my ($desc, $input, $expects_exception) =
        @specs{qw/desc input expects_exception/};

    my ($plaintext, $encoding, $public_key, $private_key, $secret, $algorithm, $extra_headers) =
        @$input{qw/plaintext encoding public_key private_key secret algorithm extra_headers/};
    $public_key  ||= $secret;
    $private_key ||= $secret;

    my $test = sub {
        my $jwe = encode_jwe $plaintext, $encoding, $public_key, $algorithm, $extra_headers;
        note "jwe: $jwe";
        return decode_jwe $jwe, $private_key;
    };
    subtest $desc => sub {
        unless ($expects_exception) {
            my $got = $test->();
            is_deeply $got, $plaintext;
        }
        else {
            eval { $test->() };
            like $@, qr/$expects_exception/;
        }
    };
}

sub test_encode_decode_object {
    my %specs = @_;
    my ($desc, $input, $expects_exception) =
        @specs{qw/desc input expects_exception/};

    my ($plaintext, $encoding, $public_key, $private_key, $secret, $algorithm, $extra_headers) =
        @$input{qw/plaintext encoding public_key private_key secret algorithm extra_headers/};
    $public_key  ||= $secret;
    $private_key ||= $secret;

    my $test = sub {
        my $jwe_obj = new JSON::WebEncryption(
                enc => $encoding,
                alg => $algorithm,
                key => $secret,
                public_key => $public_key,
                private_key => $private_key );

        my $jwe = $jwe_obj->encode( $plaintext );
        note "jwe: $jwe";
        return $jwe_obj->decode( $jwe );
    };
    subtest $desc => sub {
        unless ($expects_exception) {
            my $got = $test->();
            is_deeply $got, $plaintext;
        }