Secret Key Encryption in Perl

Key Dependent Encoding

Encryption, or Encoding, simply is the art of leaving data in obfuscated form in order to keep it secure.

It could be as simple as replacing all characters in a text file with those from a predetermined set in a manner that has the original text having a direct correlation with the encrypted / encoded version.
An example of this is seen in the Base-64 Encoding System.

Encryption could also mean adding junk data to an original data in such a way that the original data is completely defaced but can still be comfortably extracted from the encrypted version.

Encryption processes must always be consistent: i.e. the same type of encryption, or encoding, carried out on the same data or file must always produce exactly the same obfuscated output.

But with key dependent encryption, every unique key produces a completely different encoded set or obfuscated data.
This ensures better security of data since brute-forcing becomes very difficult without knowledge of the secret key used.
Also, the longer the key used, the more useless brute-forcing becomes.

This means that different individuals or firms can employ the same encryption process, but have their own unique secret key (Private Key) to encrypt data with.
Such encrypted data cannot be comfortably decrypted by a second firm using the same encryption process if the first firm can keep its key secret enough.

Recurrent Sequences or Series

Remember Sequences and Series from Ordinary Level Mathematics; Recurrent Series to be precise? They become as useful as they can be here!

Recurrent Series has the unique characteristic that all succeeding terms in a progression are totally dependent on all preceding terms - i.e. for any Recurrent Series, any n+1^th term cannot be determined unless the value of the n^th term and its predecessors are known;
and even more true is the fact that every other term in the progression is absolutely dependent on the 1^st term of the series.

So given the recurrent series

t_n+1 = 3t_n + 1;

a canonical form of the same equation can be extrapolated where any term t_n can be found only with the value of t₁ known.
This canonical equation is derived by noting and generalising the pattern that successive terms exhibit, viz:

   t_n+1 = 3t_n + 1;
Finding t₂ and onward terms
When n = 1:
   t₂ = 3t₁ + 1;
When n = 2:
   t₃ = 3(3t₁ + 1) + 1
      = 3²t₁ + 3 + 1;
When n = 3:
   t₄ = 3(3²t₁ + 3 + 1) + 1
      = 3³t₁ + 3² + 3 + 1;
When n = 4:
   t₅ = 3(3³t₁ + 3² + 3 + 1) + 1
      = 3⁴t₁ + 3³ + 3² + 3 + 1;

Following the observed pattern, it can be generalised that for any n:
T_n = 3^n-1t¹ + 3^n-2 + 3^n-3 + … + 3² + 3¹ + 3⁰;

The progression of terms after the first term suggests the summation of terms in a geometric sequence.
For any geometric progression, the n^th term, T_n, is given by
   T_n = ar^n-1;
and Sum of Terms, S_n is given viz:
   S_n = a + ar + ar² + … + ar^n-1;

S_n =	a(rⁿ - 1)
	r - 1

For our culminating geometric series, first term is 1, common ratio is 3, but last term is ar^n-2 which leaves a shorting of 1 in the power of r for any normal term.
Hence for our geometric sequence,

S_n =	a(r^n-1 - 1)
	r - 1
⇒ S_n =	3^n-1 - 1
	2

Hence, the resulting general relation for our recurrent series becomes

T_n = 3^n-1t¹ +	3^n-1 - 1
	2
or
T_n =	3^n-1(2t¹ + 1) - 1
	2

The afore property is what we will be exploiting in the Perl algorithm for encrypting data with reference to single secret keys.

Create a new Perl module file;
Call it SoleKeyEncryption.pm.
Type out the adjoining Perl code for encrypting a chunk of data with a secret key.

Important: bigint is inbuilt in Perl.
You only need to use the bigint library.

Perl Code for SoleKeyEncryption.pm Module

package SOLEKEYENCRYPTION;

BEGIN {
    require Exporter;

    # for the sake of standard
    our $VERSION = 2017.10;

    # Inherit from exporter to export functions and variables
    our @ISA = qw(Exporter);

    # Functions and variables to be exported by default
    our @EXPORT_OK = qw(encodeWord decodeWord);
}

use warnings;
use strict;
use bigint;

# simulate an object construct
sub new {
    my $self = shift;

    my $this = {};
    bless $this, $self;

    return $this;
}

sub encodeWord {
    shift;
    my $msg = shift;
    my $key = shift;
    # encoding eqn { Tn = 3^n-1(2t1 + 1) - 1 } - please use your own eqn
    #                        2
    my @encryption = ();
    my $n;
    my $t1;
    my $Tn;
    for (0 .. $#{$msg}) {
        # get unicode of this character as t1
        $t1 = ord($msg->[$_]);
        # get next key digit as n
        $n = hex($key->[$_ % ((scalar @{$key}) - 1)]);
        # use recurrence series equation to encrypt & save in base 16
        $Tn = (3**($n - 1) * (2 * $t1 + 1) - 1) / 2;
        push (@encryption, substr ($Tn->as_hex(), 2)); # remove hex designator('0x')
    }

    return \@encryption;
}

sub decodeWord {
    shift;
    my $code = shift;
    my $key = shift;
    # decoding eqn { t1 = 3^1-n(2Tn + 1) - 1 }
    #                        2
    my $decryption = "";
    my $n;
    my $t1;
    my $Tn;
    for (0 .. $#{$code}) {
        $Tn = hex($code->[$_]);
        # get next key digit as n
        $n = hex($key->[$_ % ((scalar @{$key}) - 1)]);
        # use recurrence series equation to decrypt
        $t1 = ((2 * $Tn + 1) / 3**($n - 1) - 1) / 2;
        $decryption .= chr($t1);
    }

    return $decryption;
}

1;

Main Class

#!/usr/bin/perl;

use strict;
use warnings;

use SOLEKEYENCRYPTION;

my @message = split(//, "merry xmas");
my @key = split(//, "A5FB17C4D8"); # you might want To avoid zeroes
my $go_secure = SOLEKEYENCRYPTION->new();

my $encrypted = $go_secure->encodeWord(\@message, \@key);
print ("\nMessage is '", join("", @message), "';\nEncrypted version is ", join(", ", @{$encrypted}));

my $decrypted = $go_secure->decodeWord($encrypted, \@key);
print("\n\nDecrypted version is '", $decrypted, "'.");

print "\n\n";

I have a better version / See other versions.