view release on metacpan or  search on metacpan

t/Crypt-Perl-RSA-PrivateKey.t  view on Meta::CPAN

    is_deeply(
        $prv_jwk,
        {
            %$pub_jwk,
            d => $orig{'privateExponent'},
            p => $orig{'prime1'},
            q => $orig{'prime2'},
            dp => $orig{'exponent1'},
            dq => $orig{'exponent2'},
            qi => $orig{'coefficient'},
        },
        'get_struct_for_private_jwk() gives the expected structure',
    ) or diag explain $prv_jwk;

    return;
}

sub check_raw_encrypt_decrypt : Tests(2) {
    my ($self) = @_;

    my $msg = 'Hello. This is a test.';

    my $largest_pem = $self->{'_tests'}->[-1][1];
    my $key = Crypt::Perl::RSA::Parse::private($largest_pem);

    my $crypted = $key->encrypt_raw($msg);
    isnt( $crypted, $msg, 'encrypt_raw() changes the message');

    my $decrypted = $key->decrypt_raw($crypted);
    is( $decrypted, $msg, '… and decrypt_raw() undoes that change');

    return;
}

sub check_RS384_and_RS512 : Tests(6) {
    my ($self) = @_;

    my $largest_pem = $self->{'_tests'}->[-1][1];
    my $key = Crypt::Perl::RSA::Parse::private($largest_pem);

    for my $alg ( qw( RS384 RS512 ) ) {
        my $message = rand;

        my $signature = $key->can("sign_$alg")->( $key, $message );

        is(
            $key->can("verify_$alg")->( $key, $message, $signature ),
            1,
            "$alg: Perl verified Perl’s signature",
        );

        is(
            $key->can("verify_$alg")->( $key, $message, $key->can("sign_$alg")->( $key, "00$message" ) ),
            q<>,
            "$alg: Perl non-verified a wrong signature",
        );

        SKIP: {
            skip 'No Crypt::OpenSSL::RSA; skipping', 1 if !$self->{'_has_ossl'};

            my $rsa = Crypt::OpenSSL::RSA->new_private_key($largest_pem);
            $alg =~ m<([0-9]+)> or die "huh? $alg";
            $rsa->can("use_sha$1_hash")->($rsa);
            ok(
                $rsa->verify( $message, $signature ),
                "$alg: OpenSSL verified Perl’s signature",
            );
        }
    }

    return;
}

sub test_get_public_key : Tests(3) {
    my ($self) = @_;

    my $pem = $self->{'_tests'}[-1][1];
    my $prkey = Crypt::Perl::RSA::Parse::private($pem);

    my $pbkey = $prkey->get_public_key();
    isa_ok(
        $pbkey,
        'Crypt::Perl::RSA::PublicKey',
        'get_public_key() return',
    );

    is(
        $pbkey->modulus()->as_hex(),
        $prkey->modulus()->as_hex(),
        'modulus matches',
    );

    is(
        $pbkey->exponent()->as_hex(),
        $prkey->publicExponent()->as_hex(),
        '(public) exponent matches',
    );

    return;
}

sub test_pem_der_export : Tests(2) {
    my ($self) = @_;

    SKIP: {
        skip 'No Crypt::OpenSSL::RSA; skipping', $self->num_tests() if !$self->{'_has_ossl'};

        my $pem = $self->{'_tests'}[-1][1];
        my $der = Crypt::Format::pem2der($pem);

        my $prkey = Crypt::Perl::RSA::Parse::private($pem);

        is(
            sprintf("%v.02x", $prkey->to_der()),
            sprintf("%v.02x", $der),
            'to_der()',
        );

        is(
            sprintf("%v.02x", Crypt::Format::pem2der( $prkey->to_pem() )),
            sprintf("%v.02x", $der),
            'to_pem()',
        );
    }

    return;
}

sub do_RS256_tests : Tests() {
    my ($self) = @_;

    for my $t ( @{ $self->{'_tests'} } ) {
        my ($label, $key_pem, $message, $sig_b64) = @$t;

        my $ossl_sig = MIME::Base64::decode($sig_b64);

        my $key = Crypt::Perl::RSA::Parse::private($key_pem);

        is(
            $key->verify_RS256( $message, $ossl_sig ),
            1,
            "$label: Perl verified OpenSSL’s signature",
        );

        my $signature = $key->sign_RS256( $message );

        is(
            _display_raw($signature),
            _display_raw($ossl_sig),
            "$label: Perl’s signature is as expected",
        ) or do { diag $message; diag $key_pem };

        is(
            $key->verify_RS256( $message, $signature ),
            1,
            "$label: Perl verified Perl’s signature",
        );

        my $mangled_sig = reverse $signature;

        dies_ok(
            sub { $key->verify_RS256( $message, $mangled_sig ) },
            "$label: mangled signature non-verification",
        );

        SKIP: {
            skip 'No Crypt::OpenSSL::RSA; skipping', 1 if !$self->{'_has_ossl'};

            my $rsa = Crypt::OpenSSL::RSA->new_private_key($key_pem);
            $rsa->use_sha256_hash();
            ok(
                $rsa->verify( $message, $signature ),
                "$label: OpenSSL verified Perl’s signature",
            );
        }
    }

    return;
}