[sharing time] Perl module for encrypting/decrypting/keygenerating/serializating of DSA, RSA and AES256CBC data

EncryptionManager.pm

#!/usr/bin/env perl
########################################
# Author............Robertof           #
# Website...........about.me/roberto.f #
# [email protected] #
# License...........GNU/GPL version 3  #
########################################
# Provides methods for RSA key         #
# generation, DSA signing and more.    #
########################################

package Eventimple::EncryptionManager;
use strict;
use warnings;
use Crypt::OpenSSL::RSA;
use Crypt::DSA; # DSA sign manager
use Crypt::DSA::Key; # DSA keys
use Crypt::DSA::Signature; # DSA ser/unsserialization
use Crypt::CBC; # CBC enc for Rijndael

my $dsa_obj;
my $cbc_obj;

####################################
# RSA encryption/decryption/keygen #
####################################
sub rsa_keygen
{
    my ($self, $bits) = @_;
    return Crypt::OpenSSL::RSA->generate_key ($bits);
}

sub rsa_encrypt
{
    my ($self, $rpubkey, $msg) = @_;
    return if ref ($rpubkey) ne "Crypt::OpenSSL::RSA";
    return $rpubkey->encrypt ($msg);
}

sub rsa_decrypt
{
    my ($self, $rprivkey, $msg) = @_;
    return if ref ($rprivkey) ne "Crypt::OpenSSL::RSA";
    return $rprivkey->decrypt ($msg);
}

sub rsa_pub_serialize
{
    my ($self, $rsa_obj) = @_;
    return if ref ($rsa_obj) ne "Crypt::OpenSSL::RSA";
    return $rsa_obj->get_public_key_string();
}

sub rsa_pub_unserialize
{
    my ($self, $serialized) = @_;
    return Crypt::OpenSSL::RSA->new_public_key ($serialized);
}

################################
# DSA signing/keygen/verifying #
################################

sub dsa_keygen
{
    my ($self, $bits) = @_;
    $dsa_obj = Crypt::DSA->new if not $dsa_obj;
    my $keyobj = $dsa_obj->keygen ( Size => $bits );
    # get chunks required for priv and publickey
    my $chunks = [ $keyobj->q(), $keyobj->g(), $keyobj->p() ];
    # setup keys
    my $privkey = Crypt::DSA::Key->new;
    my $pubkey  = Crypt::DSA::Key->new;
    $privkey->q ($chunks->[0]); $pubkey->q ($chunks->[0]);
    $privkey->g ($chunks->[1]); $pubkey->g ($chunks->[1]);
    $privkey->p ($chunks->[2]); $pubkey->p ($chunks->[2]);
    $pubkey->pub_key ($keyobj->pub_key());
    $privkey->priv_key ($keyobj->priv_key());
    # return
    return ( $pubkey, $privkey );
}

sub dsa_sign
{
    my ($self, $privkey, $msg) = @_;
    $dsa_obj = Crypt::DSA->new if not $dsa_obj;
    return $dsa_obj->sign (Message => $msg, Key => $privkey);
}

sub dsa_verify
{
    my ($self, $pubkey, $sig, $msg) = @_;
    $dsa_obj = Crypt::DSA->new if not $dsa_obj;
    return $dsa_obj->verify (Key => $pubkey, Message => $msg, Signature => $sig, Message => $msg);
}

sub dsa_pub_serialize
{
    my ($self, $pubkey) = @_;
    return if ref ($pubkey) ne "Crypt::DSA::Key";
    return "q=" . $pubkey->q . ",g=" . $pubkey->g . ",p=" . $pubkey->p . ",k=" . $pubkey->pub_key();
}

sub dsa_pub_unserialize
{
    my ($self, $serialized) = @_;
    return if $serialized !~ /^q=(\d+),g=(\d+),p=(\d+),k=(\d+)$/;
    my ($q, $g, $p, $key) = ($1, $2, $3, $4);
    my $pkey = Crypt::DSA::Key->new;
    $pkey->q ($q); $pkey->g ($g); $pkey->p ($p); $pkey->pub_key ($key);
    return $pkey;
}


sub dsa_sign_serialize
{
    my ($self, $sign) = @_;
    return if ref ($sign) ne "Crypt::DSA::Signature";
    return "r=" . $sign->r . ",s=" . $sign->s;
}

sub dsa_sign_unserialize
{
    my ($self, $serialized) = @_;
    return if $serialized !~ /^r=(\d+),s=(\d+)$/;
    my ($r, $s) = ($1, $2);
    my $sig = Crypt::DSA::Signature->new;
    $sig->r ($r); $sig->s ($s);
    return $sig;
}

################################
# AES-256 (Rijndael) enc/dec   #
################################

sub rijndael_init
{
    my ($self, $key) = @_;
    $cbc_obj = Crypt::CBC->new (
        -key    => $key,
        -cipher => "Rijndael",
        -header => "salt"
    );
}

sub rijndael_initialized
{
    return ( defined $cbc_obj && ref ($cbc_obj) eq "Crypt::CBC" );
}

sub rijndael_encrypt
{
    my ($self, $msg, $use_hex) = @_;
    $use_hex = ( defined $use_hex ? $use_hex : 1 );
    if (!$cbc_obj) { warn "No CBC obj, use rijndael_init()"; return 0; }
    return ($use_hex ? $cbc_obj->encrypt_hex ($msg) : $cbc_obj->encrypt ($msg));
}

sub rijndael_decrypt
{
    my ($self, $encrypted, $use_hex) = @_;
    $use_hex = ( defined $use_hex ? $use_hex : 1 );
    if (!$cbc_obj) { warn "No CBC obj, use rijndael_init()"; return 0; }
    return ($use_hex ? $cbc_obj->decrypt_hex ($encrypted) : $cbc_obj->decrypt ($encrypted));
}

#############################
# Misc functions            #
#############################

sub clear_dsa
{
    $dsa_obj = undef;
}

sub clear_rijndael
{
    $cbc_obj = undef;
}

sub clear_all
{
    clear_dsa; clear_rijndael;
}

sub DESTROY
{
    clear_all;
}
1;