Result:
found more than 453 distributions - search limited to the first 2001 files matching your query
( run in 1.726 )
Code-Crypt
view release on metacpan or search on metacpan
lib/Code/Crypt.pm view on Meta::CPAN
# ABSTRACT: Encrypt your code
use Moo;
use Crypt::CBC;
use MIME::Base64 'encode_base64';
has code => ( is => 'rw' );
has [qw( key get_key cipher )] => (
is => 'ro',
lib/Code/Crypt.pm view on Meta::CPAN
sub bootstrap {
sprintf(<<'BOOTSTRAP', $_[0]->get_key, $_[0]->cipher );
use strict;
use warnings;
use Crypt::CBC;
use MIME::Base64 'decode_base64';
my $key = do {%s};
my $cipher = Crypt::CBC->new(
-key => $key,
-cipher => '%s',
);
my $ciphertext = decode_base64(<<'DATA');
lib/Code/Crypt.pm view on Meta::CPAN
}
sub ciphercode {
my $self = shift;
my $cipher = Crypt::CBC->new(
-key => $self->key,
-cipher => $self->cipher,
);
my $code = $self->code;
lib/Code/Crypt.pm view on Meta::CPAN
read a file, prompt the user, or anything else.
=head2 C<cipher>
B<required>. The cipher used to encrypt the code. L<Crypt::Rijndael> is
recommended. See L<Crypt::CBC> for other options.
=head2 C<code>
The code that will be encrypted.
CogBase
view release on metacpan or search on metacpan
t/test-cogids view on Meta::CPAN
O5W2QIW4BZ4HVMB7LWRZUL24AA
AW4ZXHCBBPUOB2JKIDJ4Z7ZG4Q
56VYCCOTEGYENBEBKCLBCPWVY4
ZJ4YAX37ELW2WDIICTL6Z4JIKI
6C2W5QYDZFZR35YULLP7TEFUKU
GXVKQ2WZFOIYXUCBCD4U2OFUBU
DARD24SWRDNTBOX63HUZZSLTWA
QDKNVRCUKSOWZLTLNGHZDMIIWY
5GH7T3ALMWU7IINWM6HLHAI7MM
VNGZBRQ6EESHQPGRJACL2MVSM4
DCQTYQ3OUUD5GFYKTXPIA7HQC4
Combust-Spontaneously
view release on metacpan or search on metacpan
bin/combustier view on Meta::CPAN
my $cbroot = $ENV{CBROOT} = $opt->combust;
die "must have a '$cbroot' directory\n" unless(-e $cbroot);
unshift(@INC, "$cbroot/lib");
my $conf = $ENV{CBCONFIG} = 'combust.conf';
unless(-e $conf) {
open(my $fh, '>', $conf) or die "cannot write '$conf'";
print $fh "servername = localhost\n";
}
Compress-DSRC
view release on metacpan or search on metacpan
t/foo.fastq view on Meta::CPAN
+
IIIHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHGGHHFFFCDGE>B<CH7E27:,*
@test_read:0:0:80 Test Read 80
TGTCTAGGGTTGTAAGCCTTGATCATGCATTCTTCGGCGTTTCATACCCTAGCCATGGTGAACAACTATCCGTCACGAAGGTCAGTCTC
+
IIHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHGGGGGEGGFFD@CBCGEF8;0?6<)
@test_read:0:0:81 Test Read 81
ATACTCCAATCATAGCTCGCACTTGTACGACTCAAGGTGTCTGGGAAGTCCATTCACGGTTGAGTCAAATCGTAGAAACGCGCGATAAATCACCAACCCGG
+
IIHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHGFGHHGDDGHHFA>B??87E:036-9
@test_read:0:0:82 Test Read 82
Compress-Deflate7
view release on metacpan or search on metacpan
7zip/Asm/x86/AesOpt.asm view on Meta::CPAN
movdqa xmm7, [r1 + r3 offs]
OP_W op, xmm7
endm
; ---------- AES-CBC Decode ----------
CBC_DEC_UPDATE macro reg, offs
pxor reg, xmm6
movdqa xmm6, [rD + offs]
movdqa [rD + offs], reg
endm
7zip/Asm/x86/AesOpt.asm view on Meta::CPAN
nextBlocks2:
mov x3, x6
OP_W movdqa, [rD + i * 16]
LOAD_OP_W pxor, +32
DECODE LOAD_OP_W
OP_W CBC_DEC_UPDATE, i * 16
add rD, ways16
check2:
sub rN, ways
jnc nextBlocks2
7zip/Asm/x86/AesOpt.asm view on Meta::CPAN
movdqa [r1 - 32], xmm6
MY_EPILOG
; ---------- AES-CBC Encode ----------
ENCODE macro op:req
op aesenc, -16
@@:
op aesenc, +0
Compress-Stream-Zstd
view release on metacpan or search on metacpan
ext/zstd/tests/golden-compression/PR-3517-block-splitter-corruption-test view on Meta::CPAN
0000000100114101031400000000100114101031400000000100114101031400000000000010011410103010020121000400200110101112112102133020000130103110012004100203000040200001001120000100200220000001202001111101010121201010115010002004010100021001100001002200200200...
Config-Format-Ini
view release on metacpan or search on metacpan
Debian_CPANTS.txt view on Meta::CPAN
"libconvert-pem-perl", "Convert-PEM", "0.07", "1", "0"
"libconvert-tnef-perl", "Convert-TNEF", "0.17", "0", "0"
"libconvert-uulib-perl", "Convert-UUlib", "1.11", "0", "0"
"libcoy-perl", "Coy", "0.06", "0", "1"
"libcpan-distnameinfo-perl", "CPAN-DistnameInfo", "0.07", "0", "0"
"libcrypt-cbc-perl", "Crypt-CBC", "2.29", "1", "0"
"libcrypt-des-perl", "Crypt-DES", "2.05", "0", "0"
"libcrypt-dsa-perl", "Crypt-DSA", "not-uploaded", "0", "0"
"libcrypt-openssl-bignum-perl", "Crypt-OpenSSL-Bignum", "0.04", "0", "0"
"libcrypt-openssl-dsa-perl", "Crypt-OpenSSL-DSA", "0.13", "0", "1"
"libcrypt-openssl-random-perl", "Crypt-OpenSSL-Random", "0.04", "0", "1"
Config-Framework
view release on metacpan or search on metacpan
Framework.pm view on Meta::CPAN
#if the file type was binary, we can presume it's encrypted
if (-B $p{'File'}){
#use global key and crypt unless otherwise specified
foreach ('Key','Crypt'){ $p{$_} = $self->{$_} unless exists($p{$_}); }
#get the cipher
require Crypt::CBC;
my $cipher = new Crypt::CBC($p{'Key'},$p{'Crypt'});
#decrypt the data
$data = $cipher->decrypt($data);
}
#get a Data::DumpXML::Parser parser object unless we have one already
Framework.pm view on Meta::CPAN
#then we need to encrypt it before we write it.
if ((-B $p{'File'}) || ($p{'Encrypt'})){
#use global key and crypt unless otherwise specified
foreach ('Key','Crypt'){ $p{$_} = $self->{$_} unless exists($p{$_}); }
#get the cipher
require Crypt::CBC;
my $cipher = new Crypt::CBC($p{'Key'},$p{'Crypt'});
$xml_data = $cipher->encrypt($xml_data);
}
#dump it down to the file
open (OUTFILE, ">$p{'File'}") || do {
Convert-Binary-C
view release on metacpan or search on metacpan
ctlib/arch.pl view on Meta::CPAN
$use{'64BIT'} = 0;
$use{'LONGLONG'} = 0;
}
for( keys %use ) {
exists $ENV{"CBC_USE$_"} and $use{$_} = $ENV{"CBC_USE$_"};
}
# <HACK> required to support perl < 5.6.0
unless( exists $cfg{i8type} ) {
Convert-Color-HUSL
view release on metacpan or search on metacpan
70OETMJYdV3PRo/EpAHNoQsu6xW89ko4XMn4z7H0U1NcNFC4uYFfxaJHQMl3syuZ
pob8yURw5W3s4Rcon1LNmrPOztpGe0zzQIFMCe4k/H3eOqUgvBeUWfFewrYrlQ/I
eNMCth/y4XMu/NvhDhUNNsO4sLMcyfF4bmQ9jcDzkYiLLoHiUB1yqiwApmv7X2aI
3/xTjGQuJaiRqLLEdEJvvS1CikptZElKXjuIuc2yzjRGRE+1oowYlGCT+qKv9+FY
5OEiilYq4KLQPW5eNlTrO0gLUYoSTJnD6ip9tGvyeTmkc6zUJSBsm/bYKw0+UWdS
QQwlRrqCBCDnsExT0fC6hR31APgApJDT7+SmYdth01Xpa+HKgSIbegYlnTQMCS1+
zHVC3w3PktDYb6yo12HRY7CvrnsgrEQOPFRB8OjSQN7tCCApBk/JcF9zPqbRtvsO
yc/PAKeR8qm19fr7sGTv1fjkEpAcJ3hcRIIMA+nwEtE1KohpN54xGYUz3eLzFbJc
gfRykg3+hYSKVtCZvAsL+aiSHK/PVyZJo+OvEhL47UlqJtmY4KCjFM7+gpYNpQgx
Wq5cC9icKOPPGW7xPdtF
=JERF
Convert-PEM
view release on metacpan or search on metacpan
lib/Convert/PEM.pm view on Meta::CPAN
use MIME::Base64;
use Digest::MD5 qw( md5 );
use Convert::ASN1;
use Carp qw( croak );
use Convert::PEM::CBC;
use Crypt::PRNG qw( random_bytes );
use vars qw( $VERSION $DefaultCipher );
our $VERSION = '0.13'; # VERSION
our $DefaultCipher = 'DES-EDE3-CBC';
sub new {
my $class = shift;
my $pem = bless { }, $class;
$pem->init(@_);
lib/Convert/PEM.pm view on Meta::CPAN
"$head\n$headers$content$tail\n";
}
use vars qw( %CTYPES );
%CTYPES = (
'DES-CBC' => {c => 'Crypt::DES', ks=>8, bs=>8, },
'DES-EDE3-CBC' => {c => 'Crypt::DES_EDE3', ks=>24, bs=>8, },
'AES-128-CBC' => {c => 'Crypt::Rijndael', ks=>16, bs=>16, },
'AES-192-CBC' => {c => 'Crypt::Rijndael', ks=>24, bs=>16, },
'AES-256-CBC' => {c => 'Crypt::Rijndael', ks=>32, bs=>16, },
'CAMELLIA-128-CBC' => {c => 'Crypt::Camellia', ks=>16, bs=>16, },
'CAMELLIA-192-CBC' => {c => 'Crypt::Camellia', ks=>24, bs=>16, },
'CAMELLIA-256-CBC' => {c => 'Crypt::Camellia', ks=>32, bs=>16, },
'IDEA-CBC' => {c => 'Crypt::IDEA', ks=>16, bs=>8, },
'SEED-CBC' => {c => 'Crypt::SEED', ks=>16, bs=>16, },
);
#### cipher module support and configuration
sub list_ciphers { return wantarray ? sort keys %CTYPES : join(':', sort keys %CTYPES); }
lib/Convert/PEM.pm view on Meta::CPAN
my $cn = uc(+shift);
return $cn if exists $CTYPES{$cn} && exists $CTYPES{$cn}->{c};
# try to figure out what cipher is meant in an overkill fashion
$cn =~ s/(DES.*3|3DES|EDE)|(DES)|([a-zA-Z]+)(?:-?(\d+)(?:-?(\w+))?)/
if ($1) {
'DES-EDE3-CBC'
} elsif ($2) {
'DES-CBC'
}
else {
$3.($4 ? "-".$4 : "").($5 ? "-$5" : "")
}
/e;
lib/Convert/PEM.pm view on Meta::CPAN
my ($ctype, $iv) = split /,/, $param{Info};
my $cmod = $CTYPES{$ctype} or
return $pem->error("Unrecognized cipher: '$ctype'");
$iv = pack "H*", $iv;
eval "use $cmod->{c}; 1;" || croak "Failed loading cipher module '$cmod->{c}'";
my $key = Convert::PEM::CBC::bytes_to_key($passphrase,$iv,\&md5,$cmod->{ks});
my $cm = $cmod->{c}; $cm =~ s/^Crypt::(?=IDEA$)//; # fix IDEA
my $cbc = Convert::PEM::CBC->new(
Cipher => $cm->new($key),
IV => $iv );
my $buf = $cbc->decrypt($param{Ciphertext}) or
return $pem->error("Decryption failed: " . $cbc->errstr);
$buf;
lib/Convert/PEM.pm view on Meta::CPAN
return $pem->error("Unrecognized cipher: '$ctype'");
eval "use $cmod->{c}; 1;" || croak "Error loading cypher module '$cmod->{c}'";
## allow custom IV for encryption
my $iv = $pem->_getiv(%param, bs => $cmod->{bs}) or return;
my $key = Convert::PEM::CBC::bytes_to_key( $param{Password}, $iv, \&md5, $cmod->{ks} );
my $cm = $cmod->{c}; $cm =~ s/^Crypt::(?=IDEA$)//; # fix IDEA
my $cbc = Convert::PEM::CBC->new(
IV => $iv,
Cipher => $cm->new($key) );
$iv = uc join '', unpack "H*", $cbc->iv;
my $buf = $cbc->encrypt($param{Plaintext}) or
return $pem->error("Encryption failed: " . $cbc->errstr);
lib/Convert/PEM.pm view on Meta::CPAN
An encrypted file would have headers describing the type of
encryption used, and the initialization vector:
-----BEGIN DH PARAMETERS-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,C814158661DC1449
AFAZFbnQNrGjZJ/ZemdVSoZa3HWujxZuvBHzHNoesxeyqqidFvnydA==
-----END DH PARAMETERS-----
The two headers (C<Proc-Type> and C<DEK-Info>) indicate information
lib/Convert/PEM.pm view on Meta::CPAN
optional argument; if not provided the contents will be unencrypted.
=item * Cipher
The Cipher to use if a password is provided. This is an optional
argument; if not provided, the default of B<DES-EDE3-CBC> will be used
or the cipher configured is B<$Convert::PEM::DefaultCipher>. See below
for a list of supported ciphers.
=back
lib/Convert/PEM.pm view on Meta::CPAN
To list supported ciphers, use C<Convert::PEM::list_ciphers>. Here is a
list of supported Ciphers:
=over 4
=item * DES-CBC
=item * DES-EDE3-CBC
=item * AES-128-CBC
=item * AES-192-CBC
=item * AES-256-CBC
=item * CAMELLIA-128-CBC
=item * CAMELLIA-192-CBC
=item * CAMELLIA-256-CBC
=item * IDEA-CBC
=item * SEED-CBC
=back
=head2 Convert::PEM->has_cipher(I<$cipher_name>)
lib/Convert/PEM.pm view on Meta::CPAN
=item * L<Crypt::DES>
=item * L<Crypt::DES_EDE3>
=item * L<Crypt::Rijndael> - C<AES-128-CBC, AES-192-CBC and AES-256-CBC>
=item * L<Crypt::Camellia> - C<CAMELLIA-128-CBC, CAMELLIA-192-CBC and CAMELLIA-256-CBC>
=item * Crypt::L<IDEA>
=item * L<Crypt::SEED>
Convert-UUlib
view release on metacpan or search on metacpan
uulib/crc32.c view on Meta::CPAN
0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,
0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,
0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,0x6DDDE4EB,0xF4D4B551,0x83D385C7,
0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5,
0x3B6E20C8,0x4C69105E,0xD56041E4,0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,
0x35B5A8FA,0x42B2986C,0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,
0x26D930AC,0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F,
0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,0xB6662D3D,
0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,0x9FBFE4A5,0xE8B8D433,
0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,0x086D3D2D,0x91646C97,0xE6635C01,
0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,
uulib/crc32.c view on Meta::CPAN
0x14BCE1BD,0x0DA7D0FC,0x268A833F,0x3F91B27E,0x70D024B9,0x69CB15F8,0x42E6463B,0x5BFD777A,
0xDC656BB5,0xC57E5AF4,0xEE530937,0xF7483876,0xB809AEB1,0xA1129FF0,0x8A3FCC33,0x9324FD72,
},
{
0x00000000,0x01C26A37,0x0384D46E,0x0246BE59,0x0709A8DC,0x06CBC2EB,0x048D7CB2,0x054F1685,
0x0E1351B8,0x0FD13B8F,0x0D9785D6,0x0C55EFE1,0x091AF964,0x08D89353,0x0A9E2D0A,0x0B5C473D,
0x1C26A370,0x1DE4C947,0x1FA2771E,0x1E601D29,0x1B2F0BAC,0x1AED619B,0x18ABDFC2,0x1969B5F5,
0x1235F2C8,0x13F798FF,0x11B126A6,0x10734C91,0x153C5A14,0x14FE3023,0x16B88E7A,0x177AE44D,
0x384D46E0,0x398F2CD7,0x3BC9928E,0x3A0BF8B9,0x3F44EE3C,0x3E86840B,0x3CC03A52,0x3D025065,
0x365E1758,0x379C7D6F,0x35DAC336,0x3418A901,0x3157BF84,0x3095D5B3,0x32D36BEA,0x331101DD,
0x246BE590,0x25A98FA7,0x27EF31FE,0x262D5BC9,0x23624D4C,0x22A0277B,0x20E69922,0x2124F315,
0x2A78B428,0x2BBADE1F,0x29FC6046,0x283E0A71,0x2D711CF4,0x2CB376C3,0x2EF5C89A,0x2F37A2AD,
0x709A8DC0,0x7158E7F7,0x731E59AE,0x72DC3399,0x7793251C,0x76514F2B,0x7417F172,0x75D59B45,
0x7E89DC78,0x7F4BB64F,0x7D0D0816,0x7CCF6221,0x798074A4,0x78421E93,0x7A04A0CA,0x7BC6CAFD,
0x6CBC2EB0,0x6D7E4487,0x6F38FADE,0x6EFA90E9,0x6BB5866C,0x6A77EC5B,0x68315202,0x69F33835,
0x62AF7F08,0x636D153F,0x612BAB66,0x60E9C151,0x65A6D7D4,0x6464BDE3,0x662203BA,0x67E0698D,
0x48D7CB20,0x4915A117,0x4B531F4E,0x4A917579,0x4FDE63FC,0x4E1C09CB,0x4C5AB792,0x4D98DDA5,
0x46C49A98,0x4706F0AF,0x45404EF6,0x448224C1,0x41CD3244,0x400F5873,0x4249E62A,0x438B8C1D,
0x54F16850,0x55330267,0x5775BC3E,0x56B7D609,0x53F8C08C,0x523AAABB,0x507C14E2,0x51BE7ED5,
0x5AE239E8,0x5B2053DF,0x5966ED86,0x58A487B1,0x5DEB9134,0x5C29FB03,0x5E6F455A,0x5FAD2F6D,
uulib/crc32.c view on Meta::CPAN
0xC1AB88E9,0x2E69E3D7,0xC55E58D4,0x2A9C33EA,0xC8402893,0x278243AD,0xCCB5F8AE,0x23779390,
0xD27CC81D,0x3DBEA323,0xD6891820,0x394B731E,0xDB976867,0x34550359,0xDF62B85A,0x30A0D364,
0xA9580AD1,0x469A61EF,0xADADDAEC,0x426FB1D2,0xA0B3AAAB,0x4F71C195,0xA4467A96,0x4B8411A8,
0xBA8F4A25,0x554D211B,0xBE7A9A18,0x51B8F126,0xB364EA5F,0x5CA68161,0xB7913A62,0x5853515C,
0x8EF68B39,0x6134E007,0x8A035B04,0x65C1303A,0x871D2B43,0x68DF407D,0x83E8FB7E,0x6C2A9040,
0x9D21CBCD,0x72E3A0F3,0x99D41BF0,0x761670CE,0x94CA6BB7,0x7B080089,0x903FBB8A,0x7FFDD0B4,
0x78BF0EA1,0x977D659F,0x7C4ADE9C,0x9388B5A2,0x7154AEDB,0x9E96C5E5,0x75A17EE6,0x9A6315D8,
0x6B684E55,0x84AA256B,0x6F9D9E68,0x805FF556,0x6283EE2F,0x8D418511,0x66763E12,0x89B4552C,
0x5F118F49,0xB0D3E477,0x5BE45F74,0xB426344A,0x56FA2F33,0xB938440D,0x520FFF0E,0xBDCD9430,
0x4CC6CFBD,0xA304A483,0x48331F80,0xA7F174BE,0x452D6FC7,0xAAEF04F9,0x41D8BFFA,0xAE1AD4C4,
0x37E20D71,0xD820664F,0x3317DD4C,0xDCD5B672,0x3E09AD0B,0xD1CBC635,0x3AFC7D36,0xD53E1608,
0x24354D85,0xCBF726BB,0x20C09DB8,0xCF02F686,0x2DDEEDFF,0xC21C86C1,0x292B3DC2,0xC6E956FC,
0x104C8C99,0xFF8EE7A7,0x14B95CA4,0xFB7B379A,0x19A72CE3,0xF66547DD,0x1D52FCDE,0xF29097E0,
0x039BCC6D,0xEC59A753,0x076E1C50,0xE8AC776E,0x0A706C17,0xE5B20729,0x0E85BC2A,0xE147D714,
},
uulib/crc32.c view on Meta::CPAN
0x7EFAC2E6,0xE55F8E89,0x92C15C79,0x09641016,0x7DFCF999,0xE659B5F6,0x91C76706,0x0A622B69,
0x74EE59E4,0xEF4B158B,0x98D5C77B,0x03708B14,0x77E8629B,0xEC4D2EF4,0x9BD3FC04,0x0076B06B,
0x72E22F1A,0xE9476375,0x9ED9B185,0x057CFDEA,0x71E41465,0xEA41580A,0x9DDF8AFA,0x067AC695,
0x50A4D810,0xCB01947F,0xBC9F468F,0x273A0AE0,0x53A2E36F,0xC807AF00,0xBF997DF0,0x243C319F,
0x56A8AEEE,0xCD0DE281,0xBA933071,0x21367C1E,0x55AE9591,0xCE0BD9FE,0xB9950B0E,0x22304761,
0x5CBC35EC,0xC7197983,0xB087AB73,0x2B22E71C,0x5FBA0E93,0xC41F42FC,0xB381900C,0x2824DC63,
0x5AB04312,0xC1150F7D,0xB68BDD8D,0x2D2E91E2,0x59B6786D,0xC2133402,0xB58DE6F2,0x2E28AA9D,
0x489503E8,0xD3304F87,0xA4AE9D77,0x3F0BD118,0x4B933897,0xD03674F8,0xA7A8A608,0x3C0DEA67,
0x4E997516,0xD53C3979,0xA2A2EB89,0x3907A7E6,0x4D9F4E69,0xD63A0206,0xA1A4D0F6,0x3A019C99,
0x448DEE14,0xDF28A27B,0xA8B6708B,0x33133CE4,0x478BD56B,0xDC2E9904,0xABB04BF4,0x3015079B,
0x428198EA,0xD924D485,0xAEBA0675,0x351F4A1A,0x4187A395,0xDA22EFFA,0xADBC3D0A,0x36197165,
uulib/crc32.c view on Meta::CPAN
0xBD8D91AB,0x601B482E,0xDDD124E0,0x0047FD65,0x7D34FB3D,0xA0A222B8,0x1D684E76,0xC0FE97F3,
0xE78E42C6,0x3A189B43,0x87D2F78D,0x5A442E08,0x27372850,0xFAA1F1D5,0x476B9D1B,0x9AFD449E,
0x098A3771,0xD41CEEF4,0x69D6823A,0xB4405BBF,0xC9335DE7,0x14A58462,0xA96FE8AC,0x74F93129,
0x5389E41C,0x8E1F3D99,0x33D55157,0xEE4388D2,0x93308E8A,0x4EA6570F,0xF36C3BC1,0x2EFAE244,
0x0EF3DA5E,0xD36503DB,0x6EAF6F15,0xB339B690,0xCE4AB0C8,0x13DC694D,0xAE160583,0x7380DC06,
0x54F00933,0x8966D0B6,0x34ACBC78,0xE93A65FD,0x944963A5,0x49DFBA20,0xF415D6EE,0x29830F6B,
0xBAF47C84,0x6762A501,0xDAA8C9CF,0x073E104A,0x7A4D1612,0xA7DBCF97,0x1A11A359,0xC7877ADC,
0xE0F7AFE9,0x3D61766C,0x80AB1AA2,0x5D3DC327,0x204EC57F,0xFDD81CFA,0x40127034,0x9D84A9B1,
0xA06A2517,0x7DFCFC92,0xC036905C,0x1DA049D9,0x60D34F81,0xBD459604,0x008FFACA,0xDD19234F,
0xFA69F67A,0x27FF2FFF,0x9A354331,0x47A39AB4,0x3AD09CEC,0xE7464569,0x5A8C29A7,0x871AF022,
0x146D83CD,0xC9FB5A48,0x74313686,0xA9A7EF03,0xD4D4E95B,0x094230DE,0xB4885C10,0x691E8595,
uulib/crc32.c view on Meta::CPAN
0x4E87F0BB,0xF77C2B53,0xE601412A,0x5FFA9AC2,0xC4FB95D8,0x7D004E30,0x6C7D2449,0xD586FFA1,
0x810E3C3C,0x38F5E7D4,0x29888DAD,0x90735645,0x0B72595F,0xB28982B7,0xA3F4E8CE,0x1A0F3326,
0x0AE56FF4,0xB31EB41C,0xA263DE65,0x1B98058D,0x80990A97,0x3962D17F,0x281FBB06,0x91E460EE,
0xC56CA373,0x7C97789B,0x6DEA12E2,0xD411C90A,0x4F10C610,0xF6EB1DF8,0xE7967781,0x5E6DAC69,
0xC642CE25,0x7FB915CD,0x6EC47FB4,0xD73FA45C,0x4C3EAB46,0xF5C570AE,0xE4B81AD7,0x5D43C13F,
0x09CB02A2,0xB030D94A,0xA14DB333,0x18B668DB,0x83B767C1,0x3A4CBC29,0x2B31D650,0x92CA0DB8,
0x8220516A,0x3BDB8A82,0x2AA6E0FB,0x935D3B13,0x085C3409,0xB1A7EFE1,0xA0DA8598,0x19215E70,
0x4DA99DED,0xF4524605,0xE52F2C7C,0x5CD4F794,0xC7D5F88E,0x7E2E2366,0x6F53491F,0xD6A892F7,
0x847C8BC6,0x3D87502E,0x2CFA3A57,0x9501E1BF,0x0E00EEA5,0xB7FB354D,0xA6865F34,0x1F7D84DC,
0x4BF54741,0xF20E9CA9,0xE373F6D0,0x5A882D38,0xC1892222,0x7872F9CA,0x690F93B3,0xD0F4485B,
0xC01E1489,0x79E5CF61,0x6898A518,0xD1637EF0,0x4A6271EA,0xF399AA02,0xE2E4C07B,0x5B1F1B93,
0x0F97D80E,0xB66C03E6,0xA711699F,0x1EEAB277,0x85EBBD6D,0x3C106685,0x2D6D0CFC,0x9496D714,
0x0CB9B558,0xB5426EB0,0xA43F04C9,0x1DC4DF21,0x86C5D03B,0x3F3E0BD3,0x2E4361AA,0x97B8BA42,
0xC33079DF,0x7ACBA237,0x6BB6C84E,0xD24D13A6,0x494C1CBC,0xF0B7C754,0xE1CAAD2D,0x583176C5,
0x48DB2A17,0xF120F1FF,0xE05D9B86,0x59A6406E,0xC2A74F74,0x7B5C949C,0x6A21FEE5,0xD3DA250D,
0x8752E690,0x3EA93D78,0x2FD45701,0x962F8CE9,0x0D2E83F3,0xB4D5581B,0xA5A83262,0x1C53E98A,
},
{
Cookie
view release on metacpan or search on metacpan
lib/Cookie.pm view on Meta::CPAN
if( @_ )
{
my $algo = shift( @_ );
if( defined( $algo ) && CORE::length( $algo ) )
{
$self->_load_class( 'Crypt::Mode::CBC', { version => CRYPTX_VERSION } ) || return( $self->pass_error );
# try-catch
local $@;
eval
{
# Crypt::Mode::CBC dies when it is unhappy, but we catch a null return
# value anyway just in case
my $o = Crypt::Mode::CBC->new( $algo ) ||
die( "Unsupported algorithm \"$algo\"\n" );
$self->_set_get_scalar_as_object( 'algo', $algo );
$self->reset(1);
};
if( $@ )
lib/Cookie.pm view on Meta::CPAN
my( $key, $algo, $iv ) = @_;
return( $self->error( "Key provided is empty!" ) ) if( !defined( $key ) || !CORE::length( "$key" ) );
return( $self->error( "No algorithm was provided to encrypt cookie value. You can choose any <NAME> for which there exists Crypt::Cipher::<NAME>" ) ) if( !defined( $algo ) || !CORE::length( "$algo" ) );
$iv //= '';
$self->_load_class( 'Crypt::Mode::CBC', { version => CRYPTX_VERSION } ) || return( $self->pass_error );
$self->_load_class( 'Bytes::Random::Secure' ) || return( $self->pass_error );
my $crypt = eval
{
Crypt::Mode::CBC->new( "$algo" );
};
if( $@ )
{
return( $self->error( "Error getting the encryption objects for algorithm \"$algo\": $@" ) );
}
$crypt or return( $self->error( "Unable to create a Crypt::Mode::CBC object." ) );
my $class = "Crypt::Cipher::${algo}";
$self->_load_class( $class ) || return( $self->pass_error );
my $key_len = $class->keysize;
my $block_len = $class->blocksize;
return( $self->error( "The size of the key provided (", CORE::length( $key ), ") does not match the minimum key size required for this algorithm \"$algo\" (${key_len})." ) ) if( CORE::length( $key ) < $key_len );
lib/Cookie.pm view on Meta::CPAN
=head1 SIGNED COOKIES
As shown in the L</SYNOPSIS> you can sign cookies effortlessly. This package has taken all the hassle of doing it for you.
To use this feature you need to have installed L<Crypt::Mode::CBC> which is part of L<CryptX>
The methods available to use for cookie integrity protection are: L</key>, L</sign> to enable cookie signature, L</is_valid> to check if the signature is valid.
Cookie signature is performed by L<CryptX>, which is an XS module, and thus very fast.
=head1 ENCRYPTED COOKIES
As shown in the L</SYNOPSIS> you can encrypt cookies effortlessly. This package has taken all the hassle of doing it for you.
To use this feature you need to have installed L<Crypt::Mode::CBC> which is part of L<CryptX>
The methods available to use for cookie encryption are: L</algo> to set the desired algorithm, L</key>, L</encrypt> to enable encryption, L</decrypt> to decrypt the cookie value, and optionally L</initialisation_vector>.
Cookie encryption is performed by L<CryptX>, which is an XS module, and thus very fast.
Couchbase-Client
view release on metacpan or search on metacpan
src/Makefile.PL view on Meta::CPAN
#!/usr/bin/perl
package PLCBCDeps;
use strict;
use warnings;
use ExtUtils::MakeMaker;
use Dir::Self;
Crypt-ARIA
view release on metacpan or search on metacpan
lib/Crypt/ARIA.pm view on Meta::CPAN
my $decrypted = $aria->decrypt_ecb( $cipher );
# note that $decrypt may not be same as $plain, because it is appended
# null bytes to.
# CBC mode
use Crypt::CBC;
my $cbc = Crypt::CBC->new(
-cipher => Crypt::ARIA->new()->set_key( $key ),
-iv => $initial_vector,
-header => 'none';
-padding => 'none';
);
lib/Crypt/ARIA.pm view on Meta::CPAN
It returns a ciphertext of 16 bytes.
If you want to encrypt a text of different length,
you have to choose the operation mode and the padding method.
You may implement them by yourself or use another module for them.
C<Crypt::ARIA> is designed to be compatible with L<Crypt::CBC>.
Therefore, you can use C<Crypt::CBC> to use CBC mode with several
padding methods.
use Crypt::CBC;
my $cbc = Crypt::CBC->new(
-cipher => Crypt::ARIA->new()->set_key( $key ),
-iv => $initial_vector,
-header => 'none';
-padding => 'none';
);
lib/Crypt/ARIA.pm view on Meta::CPAN
NOTE: If the length of $plain is not n-times of 16 exactly,
C<encrypt_ecb()> appends null bytes to fill it. If the length
is n-times of 16 exactly, $plain would be untouched. This means
you should have to deliver the original length of $plain to the
receiver. You had better use other module like L<Crypt::CBC> that
provides advanced operation mode and padding method.
This method is just for test purpose.
=item decrypt_ecb
lib/Crypt/ARIA.pm view on Meta::CPAN
=back
=head1 SEE ALSO
L<Crypt::CBC>, L<Crypt::SEED>
L<http://en.wikipedia.org/wiki/ARIA_%28cipher%29>
L<http://210.104.33.10/ARIA/index-e.html>
Crypt-Anubis
view release on metacpan or search on metacpan
__END__
=head1 NAME
Crypt::Anubis - Crypt::CBC-compliant block cipher
=head1 ABSTRACT
Anubis is a variable-length key, 128-bit block cipher designed by
Vincent Rijmen and Paulo S. L. M. Barreto.
Anubis is a variable-length key, 128-bit block cipher designed by
Vincent Rijmen and Paulo S. L. M. Barreto. Key length can be 128, 160,
192, 224, 256, 288, or 320 bits. The default key length used in this
implementation is 128 bits (16 bytes).
This module supports the Crypt::CBC interface, with the following
functions.
=head2 Functions
=over
#!/usr/local/bin/perl
use diagnostics;
use strict;
use warnings;
use Crypt::CBC; # CBC automatically loads Anubis for us
# when using Crypt::CBC, key may be of ANY length
my $key = "0123456789abcdef";
# IV must be exactly 16 bytes long
my $IV = pack "H32", 0;
my $cipher = Crypt::CBC->new({'key' => $key,
'cipher' => 'Anubis',
'iv' => $IV,
'regenerate_key' => 1,
'padding' => 'standard',
'prepend_iv' => 0
});
# when using Crypt::CBC, plaintext may be of ANY length
my $plaintext1 = "This is a test";
my $ciphertext = $cipher->encrypt($plaintext1);
my $plaintext2 = $cipher->decrypt($ciphertext);
print "Decryption OK\n" if ($plaintext1 eq $plaintext2);
=head1 MORE EXAMPLES
See B<Crypt::CBC> for more examples using CBC mode. See also the
"examples" and "t" directories for some more examples.
=head1 SEE ALSO
B<Crypt::Khazad> and B<Crypt::Misty1>
Crypt-AppleTwoFish
view release on metacpan or search on metacpan
lib/Crypt/AppleTwoFish.pm view on Meta::CPAN
my $h = ( $b * 0xFFFFCB29 + 0x417E ) | ( $b * 0x698AC6 + 0xD597C97D );
my $j = $h | 0xFF;
my $k = ( $b * 0xFF96753A + 0x2A683682 ) ^ $g;
my $m =
( $b * 0xD2ABDE + $j * 0xFFFFFFFC + $k * 0xFFFFFFFE + 0xAB3015F3 ) |
( $a * 0xA413E8 + $d * 0xFFFFFFFE + $f * 0xFFFFFFFC + 0xDECBC5F3 );
$digest_bytes[ $i + 1 ] = (
(
$a * 0x3FC1ACD4 +
$b * 0x5B76357 +
( $d + $k + $m ) * 0x71070EE7 +
Crypt-Bear
view release on metacpan or search on metacpan
lib/Crypt/Bear/AES_CBC/Dec.pm view on Meta::CPAN
package Crypt::Bear::AES_CBC::Dec;
$Crypt::Bear::AES_CBC::Dec::VERSION = '0.004';
use Crypt::Bear;
1;
# ABSTRACT: AES-CBC decoder class in BearSSL
__END__
=pod
=encoding UTF-8
=head1 NAME
Crypt::Bear::AES_CBC::Dec - AES-CBC decoder class in BearSSL
=head1 VERSION
version 0.004
=head1 SYNOPSIS
my $decoder = Crypt::Bear::AES_CBC::Dec->new($key);
my $plaintext = $d->run($iv, $cipher);
=head1 DESCRIPTION
This class represents an AES-CBC decoder. It's a subclass of L<Crypt::Bear::CBC::Dec> and inherits its C<run> and C<blocksize> methods.
=head1 METHODS
=head2 new($key)
This initializes a new AES_CBC decoder with C<$key>. C<$key> much be appropriately sized for AES (16, 24, or 32 bytes).
=head1 AUTHOR
Leon Timmermans <fawaka@gmail.com>
Crypt-Blowfish
view release on metacpan or search on metacpan
Blowfish.pm view on Meta::CPAN
my $cipher = new Crypt::Blowfish $key;
my $ciphertext = $cipher->encrypt($plaintext);
my $plaintext = $cipher->decrypt($ciphertext);
You probably want to use this in conjunction with
a block chaining module like Crypt::CBC.
=head1 DESCRIPTION
Blowfish is capable of strong encryption and can use key sizes up
to 56 bytes (a 448 bit key). You're encouraged to take advantage
Blowfish.pm view on Meta::CPAN
Please see the README document for platforms and performance
tests.
=head1 NOTES
The module is capable of being used with Crypt::CBC. You're
encouraged to read the perldoc for Crypt::CBC if you intend to
use this module for Cipher Block Chaining modes. In fact, if
you have any intentions of encrypting more than eight bytes of
data with this, or any other block cipher, you're going to need
B<some> type of block chaining help. Crypt::CBC tends to be
very good at this. If you're not going to encrypt more than
eight bytes, your data B<must> be B<exactly> eight bytes long.
If need be, do your own padding. "\0" as a null byte is perfectly
valid to use for this.
=head1 SEE ALSO
Crypt::CBC,
Crypt::DES,
Crypt::IDEA
Bruce Schneier, I<Applied Cryptography>, 1995, Second Edition,
published by John Wiley & Sons, Inc.
Crypt-Blowfish_PP
view release on metacpan or search on metacpan
Blowfish_PP.pm view on Meta::CPAN
Matthew Byng-Maddick <C<mbm@colondot.net>>
=head1 SEE ALSO
http://www.counterpane.com/,L<Crypt::CBC>
=cut
1;
Crypt-CAST5
view release on metacpan or search on metacpan
Crypt::CAST5 - CAST5 block cipher
=head1 SYNOPSIS
use Crypt::CBC;
my $crypt = Crypt::CBC->new({
key => "secret key",
cipher => "CAST5",
});
my $message = "All mimsy were the borogoves";
=head1 FUNCTIONS
=head2 blocksize
Returns the CAST5 block size, which is 8 bytes. This function exists
so that Crypt::CAST5 can work with Crypt::CBC.
=head2 keysize
Returns the maximum CAST5 key size, 16 bytes.
80 bits or less, encryption and decryption will be somewhat faster.
It is best for the key to be random binary data, not something printable
like a password. A message digest function may be useful for converting
a password to an encryption key; see L<Digest::SHA1> or L<Digest::MD5>.
Note that Crypt::CBC runs the given "key" through MD5 to get the actual
encryption key.
=head2 encrypt
$ciphertext = $cast5->encrypt($plaintext);
Encrypt a block of plaintext using the current encryption key, and return
the corresponding ciphertext. The input must be 8 bytes long, and the output
has the same length. Note that the encryption is in ECB mode, which means
that it encrypts each block independently. That can leave you vulnerable
to dictionary attacks, so it is generally best to use some form of chaining
between blocks; see L<Crypt::CBC>.
=head2 decrypt
$plaintext = $cast5->decrypt($ciphertext);
=head1 SEE ALSO
RFC 2144, "The CAST-128 Encryption Algorithm", C. Adams, May 1997
L<Crypt::CBC>
=head1 AUTHOR
Bob Mathews, E<lt>bobmathews@alumni.calpoly.eduE<gt>
Crypt-CAST5_PP
view release on metacpan or search on metacpan
CAST5_PP.pm view on Meta::CPAN
Crypt::CAST5_PP - CAST5 block cipher in pure Perl
=head1 SYNOPSIS
use Crypt::CBC;
my $crypt = Crypt::CBC->new({
key => "secret key",
cipher => "CAST5_PP",
});
my $message = "All mimsy were the borogoves";
CAST5_PP.pm view on Meta::CPAN
=head1 FUNCTIONS
=head2 blocksize
Returns the CAST5 block size, which is 8 bytes. This function exists
so that Crypt::CAST5_PP can work with Crypt::CBC.
=head2 keysize
Returns the maximum CAST5 key size, 16 bytes.
CAST5_PP.pm view on Meta::CPAN
80 bits or less, encryption and decryption will be somewhat faster.
It is best for the key to be random binary data, not something printable
like a password. A message digest function may be useful for converting
a password to an encryption key; see L<Digest::SHA1> or L<Digest::MD5>.
Note that Crypt::CBC runs the given "key" through MD5 to get the actual
encryption key.
=head2 encrypt
$ciphertext = $cast5->encrypt($plaintext);
CAST5_PP.pm view on Meta::CPAN
Encrypt a block of plaintext using the current encryption key, and return
the corresponding ciphertext. The input must be 8 bytes long, and the output
has the same length. Note that the encryption is in ECB mode, which means
that it encrypts each block independently. That can leave you vulnerable
to dictionary attacks, so it is generally best to use some form of chaining
between blocks; see L<Crypt::CBC>.
=head2 decrypt
$plaintext = $cast5->decrypt($ciphertext);
CAST5_PP.pm view on Meta::CPAN
=head1 SEE ALSO
RFC 2144, "The CAST-128 Encryption Algorithm", C. Adams, May 1997
L<Crypt::CBC>
=head1 AUTHOR
Bob Mathews, <bobmathews@alumni.calpoly.edu>
Crypt-CBC
view release on metacpan or search on metacpan
#!/usr/bin/perl
use lib '../blib/lib';
use Getopt::Std;
use Crypt::CBC;
use strict vars;
my %options;
getopts('edk:p:i:o:',\%options) || die <<USAGE;
open(STDOUT,">$options{'o'}") or die "$options{'o'}: $!"
if $options{'o'};
my $decrypt = $options{'d'} and !$options{'e'};
my $key = $options{'k'} || $options{'p'} || get_key(!$decrypt);
my $cipher = Crypt::CBC->new(-pass => $key,
-cipher => 'Crypt::Cipher::AES',
-pbkdf => 'pbkdf2',
-chain_mode => 'ctr',
) || die "Couldn't create CBC object";
$cipher->start($decrypt ? 'decrypt' : 'encrypt');
my $in;
while (@ARGV) {
my $file = shift @ARGV;
Crypt-CBCeasy
view release on metacpan or search on metacpan
# easy en/decryption with DES/IDEA/Blowfish and some other ciphers
# Mike Blazer <blazer@mail.nevalink.ru>
package Crypt::CBCeasy;
use 5.003;
use Crypt::CBC;
use Carp;
use Symbol;
use strict;
no strict 'refs';
$VERSION = '0.24';
@DEFAULT_CIPHERS = qw/DES IDEA Blowfish/;
#--------------
sub useCBC {
#--------------
# $from - handler (r), filename or just plain or encrypted text
# $to - handler (r), or filename. If '' or undef sub returns $to-string
my ($key, $from, $to) = @_;
my $sub = (caller(1))[3]; # caller subroutine
$LastCipher = $algorithm;
my ($fhi, $fho, $fromFile, $INopened, $OUTopened,
$buffer, $fromStr, $toStr, $cipher);
croak "CBCeasy: source not defined\n" unless defined $from;
croak "CBCeasy: key not defined\n" unless defined $key;
croak "CBCeasy: I can do only `encipher' or `decipher'\n"
unless $op && $op =~ /^(encipher|decipher)$/i;
if ((UNIVERSAL::isa($from, 'GLOB') || # \*HANDLE
UNIVERSAL::isa(\$from,'GLOB') # *HANDLE
) && defined fileno $from
} elsif (-e $from && -r _) { # filename
$fhi = gensym;
$fromFile = 1;
$INopened = 1;
open ($fhi, $from) || croak "CBCeasy: file `$from' not found/readable\n";
} elsif (-e $from && !-r _) { # filename
croak "CBCeasy: file `$from' not readable\n";
} else { # stream itself in $from
}
$cipher = new Crypt::CBC($key, $algorithm);
$cipher->start(lc $op);
if ($fromFile) {
binmode $fhi;
$fho = $to;
} else { # filename
$fho = gensym;
$OUTopened = 1;
open ($fho, ">$to") || croak "CBCeasy: can't write file `$to'\n";
}
binmode $fho;
print $fho $toStr;
my $pkg = shift;
for (@_ ? @_ : @DEFAULT_CIPHERS) {
eval <<"E_O_P" unless defined *{"$_\::encipher"}{CODE};
sub $_\::encipher { useCBC(\@_) }
sub $_\::decipher { useCBC(\@_) }
E_O_P
}
}
1;
__END__
=head1 NAME
Crypt::CBCeasy - Easy things make really easy with Crypt::CBC
=head1 SYNOPSIS
use Crypt::CBCeasy; # !!! YOU can not 'require' this module !!!
IDEA::encipher($my_key, "plain-file", "crypted-file");
$plain_text = DES::decipher($my_key, \*CRYPTO_FILE);
$crypted = Blowfish::encipher($my_key, \*PLAIN_SOCKET);
=head1 ABSTRACT
This module is just a helper for Crypt::CBC to make simple and
usual jobs just one-liners.
The current version of the module is available at CPAN.
=head1 DESCRIPTION
After you call this module as
use Crypt::CBCeasy IMPORT-LIST;
it creates the C<encipher()> and C<decipher()> functions in all
namespaces (packages) listed in the C<IMPORT-LIST>.
Without the C<IMPORT-LIST> it creates these 2 functions
in the B<DES::>, B<IDEA::> and
B<Blowfish::> namespaces by default
to stay compatible with the previous versions
that were capable to handle only these 3 ciphers.
You have to install C<Crypt::CBC> v. 1.22 or later to work with C<Blowfish>.
Sure IDEA:: functions will work only if you have Crypt::IDEA installed,
DES:: - if you have Crypt::DES, Blowfish:: - if you have Crypt::Blowfish
and Crypt::CBC is version 1.22 or above etc.
Here's the list of the ciphers that could be called via the
C<Crypt::CBCeasy> interface today (in fact the same modules
that are C<Crypt::CBC> compatible):
Cipher CPAN module
DES Crypt::DES
IDEA Crypt::IDEA
will produce the HTML-docs.
This module requires
Crypt::CBC by Lincoln Stein, lstein@cshl.org
v.1.20 or later.
one or more of
Crypt::IDEA, Crypt::DES, Crypt::Blowfish, Crypt::Blowfish_PP,
Crypt::Twofish2, Crypt::DES_PP or other Crypt::CBC compatible modules.
=head1 CAVEATS
This module has been created and tested in a Win95/98/2000Pro environment
with Perl 5.004_02 and ActiveState ActivePerl build 618.
DAMN!
Fixed.
And the test is modified so that this will never happen again.
Now you can define the list of ciphers that are compatible
with Crypt::CBC in the import list.
You can not call this module with the "require" statement. This
is incompatible with the older versions.
0.23 Crypt::Rijndael 0.02 compatibility was approved.
Tests are some more complex now.
Please report.
=head1 VERSION
This man page documents "Crypt::CBCeasy" version 0.24
February 18, 2001
=head1 AUTHOR
http://base.dux.ru/guest/fno/perl/
=head1 SEE ALSO
Crypt::CBC
=head1 COPYRIGHT
Copyright (C) 2000-2001 Mike Blazer.
Crypt-CCM
view release on metacpan or search on metacpan
lib/Crypt/CCM.pm view on Meta::CPAN
NIST Special Publication 800-38C - Recommendation for Block Cipher Modes of Operation: The CCM Mode for Authentication and Confidentiality.
L<http://csrc.nist.gov/CryptoToolkit/modes/800-38_Series_Publications/SP800-38C.pdf>
RFC 3610 - Counter with CBC-MAC (CCM)
L<http://tools.ietf.org/html/rfc3610>
=head1 AUTHOR
Crypt-Camellia
view release on metacpan or search on metacpan
lib/Crypt/Camellia.pm view on Meta::CPAN
my $cipher = Crypt::Camellia->new($key);
my $ciphertext = $cipher->encrypt($plaintext);
my $plaintext = $cipher->decrypt($ciphertext);
# more likely
use Crypt::CBC;
$cipher = Crypt::CBC->new( -key => 'my secret key',
-cipher => 'Camellia'
);
=head1 DESCRIPTION
lib/Crypt/Camellia.pm view on Meta::CPAN
decrypt()
=back
Like many Crypt:: modules like L<Crypt::Blowfish> and L<Crypt::DES>,
this module works as a backend of L<Crypt::CBC>.
=head1 FUNCTIONS
=over 2
lib/Crypt/Camellia.pm view on Meta::CPAN
my $ciphertext = $cipher->encrypt("plaintex");# SEE NOTES
print unpack("H16", $ciphertext), "\n";
=head1 NOTES
For practical uses use this module via L<Crypt::CBC> rather than directly.
=head1 SEE ALSO
L<Crypt::CBC>,
L<Crypt::Rijndael>,
L<Crypt::DES>,
L<Crypt::IDEA>
=head1 AUTHOR
Crypt-Camellia_PP
view release on metacpan or search on metacpan
lib/Crypt/Camellia_PP.pm view on Meta::CPAN
my $cipher_string = $camellia->encrypt($src);
my $plain_string = $camellia->decrypt($cipher_string);
$plain_string eq $src;
=head2 With Crypt::CBC module
use Crypt::CBC;
my $cbc = Crypt::CBC->new({
cipher => 'Crypt::Camellia_PP',
key => pack('H*', '00112233445566778899aabbccddeeff'),
iv => pack('H*', '00000000000000000000000000000000'),
literal_key => 1,
header => 'none',
Crypt-Cryptoki
view release on metacpan or search on metacpan
lib/Crypt/Cryptoki/Constant.pm view on Meta::CPAN
CKK_X9_42_DH
)],
'mechanisms' => [qw(
CKM_ACTI
CKM_ACTI_KEY_GEN
CKM_AES_CBC
CKM_AES_CBC_ENCRYPT_DATA
CKM_AES_CBC_PAD
CKM_AES_CTR
CKM_AES_ECB
CKM_AES_ECB_ENCRYPT_DATA
CKM_AES_KEY_GEN
CKM_AES_MAC
CKM_AES_MAC_GENERAL
CKM_ARIA_CBC
CKM_ARIA_CBC_ENCRYPT_DATA
CKM_ARIA_CBC_PAD
CKM_ARIA_ECB
CKM_ARIA_ECB_ENCRYPT_DATA
CKM_ARIA_KEY_GEN
CKM_ARIA_MAC
CKM_ARIA_MAC_GENERAL
CKM_BATON_CBC128
CKM_BATON_COUNTER
CKM_BATON_ECB128
CKM_BATON_ECB96
CKM_BATON_KEY_GEN
CKM_BATON_SHUFFLE
CKM_BATON_WRAP
CKM_BLOWFISH_CBC
CKM_BLOWFISH_KEY_GEN
CKM_CAMELLIA_CBC
CKM_CAMELLIA_CBC_ENCRYPT_DATA
CKM_CAMELLIA_CBC_PAD
CKM_CAMELLIA_CTR
CKM_CAMELLIA_ECB
CKM_CAMELLIA_ECB_ENCRYPT_DATA
CKM_CAMELLIA_KEY_GEN
CKM_CAMELLIA_MAC
CKM_CAMELLIA_MAC_GENERAL
CKM_CAST128_CBC
CKM_CAST128_CBC_PAD
CKM_CAST128_ECB
CKM_CAST128_KEY_GEN
CKM_CAST128_MAC
CKM_CAST128_MAC_GENERAL
CKM_CAST3_CBC
CKM_CAST3_CBC_PAD
CKM_CAST3_ECB
CKM_CAST3_KEY_GEN
CKM_CAST3_MAC
CKM_CAST3_MAC_GENERAL
CKM_CAST5_CBC
CKM_CAST5_CBC_PAD
CKM_CAST5_ECB
CKM_CAST5_KEY_GEN
CKM_CAST5_MAC
CKM_CAST5_MAC_GENERAL
CKM_CAST_CBC
CKM_CAST_CBC_PAD
CKM_CAST_ECB
CKM_CAST_KEY_GEN
CKM_CAST_MAC
CKM_CAST_MAC_GENERAL
CKM_CDMF_CBC
CKM_CDMF_CBC_PAD
CKM_CDMF_ECB
CKM_CDMF_KEY_GEN
CKM_CDMF_MAC
CKM_CDMF_MAC_GENERAL
CKM_CMS_SIG
CKM_CONCATENATE_BASE_AND_DATA
CKM_CONCATENATE_BASE_AND_KEY
CKM_CONCATENATE_DATA_AND_BASE
CKM_DES2_KEY_GEN
CKM_DES3_CBC
CKM_DES3_CBC_ENCRYPT_DATA
CKM_DES3_CBC_PAD
CKM_DES3_ECB
CKM_DES3_ECB_ENCRYPT_DATA
CKM_DES3_KEY_GEN
CKM_DES3_MAC
CKM_DES3_MAC_GENERAL
CKM_DES_CBC
CKM_DES_CBC_ENCRYPT_DATA
CKM_DES_CBC_PAD
CKM_DES_CFB64
CKM_DES_CFB8
CKM_DES_ECB
CKM_DES_ECB_ENCRYPT_DATA
CKM_DES_KEY_GEN
lib/Crypt/Cryptoki/Constant.pm view on Meta::CPAN
CKM_FASTHASH
CKM_FORTEZZA_TIMESTAMP
CKM_GENERIC_SECRET_KEY_GEN
CKM_HOTP
CKM_HOTP_KEY_GEN
CKM_IDEA_CBC
CKM_IDEA_CBC_PAD
CKM_IDEA_ECB
CKM_IDEA_KEY_GEN
CKM_IDEA_MAC
CKM_IDEA_MAC_GENERAL
CKM_JUNIPER_CBC128
CKM_JUNIPER_COUNTER
CKM_JUNIPER_ECB128
CKM_JUNIPER_KEY_GEN
CKM_JUNIPER_SHUFFLE
CKM_JUNIPER_WRAP
lib/Crypt/Cryptoki/Constant.pm view on Meta::CPAN
CKM_MD5_HMAC
CKM_MD5_HMAC_GENERAL
CKM_MD5_KEY_DERIVATION
CKM_MD5_RSA_PKCS
CKM_PBA_SHA1_WITH_SHA1_HMAC
CKM_PBE_MD2_DES_CBC
CKM_PBE_MD5_CAST128_CBC
CKM_PBE_MD5_CAST3_CBC
CKM_PBE_MD5_CAST5_CBC
CKM_PBE_MD5_CAST_CBC
CKM_PBE_MD5_DES_CBC
CKM_PBE_SHA1_CAST128_CBC
CKM_PBE_SHA1_CAST5_CBC
CKM_PBE_SHA1_DES2_EDE_CBC
CKM_PBE_SHA1_DES3_EDE_CBC
CKM_PBE_SHA1_RC2_128_CBC
CKM_PBE_SHA1_RC2_40_CBC
CKM_PBE_SHA1_RC4_128
CKM_PBE_SHA1_RC4_40
CKM_PKCS5_PBKD2
CKM_RC2_CBC
CKM_RC2_CBC_PAD
CKM_RC2_ECB
CKM_RC2_KEY_GEN
CKM_RC2_MAC
CKM_RC2_MAC_GENERAL
CKM_RC4
CKM_RC4_KEY_GEN
CKM_RC5_CBC
CKM_RC5_CBC_PAD
CKM_RC5_ECB
CKM_RC5_KEY_GEN
CKM_RC5_MAC
CKM_RC5_MAC_GENERAL
CKM_RIPEMD128
lib/Crypt/Cryptoki/Constant.pm view on Meta::CPAN
CKM_SHA512_HMAC
CKM_SHA512_HMAC_GENERAL
CKM_SHA512_KEY_DERIVATION
CKM_SHA512_RSA_PKCS
CKM_SHA512_RSA_PKCS_PSS
CKM_SKIPJACK_CBC64
CKM_SKIPJACK_CFB16
CKM_SKIPJACK_CFB32
CKM_SKIPJACK_CFB64
CKM_SKIPJACK_CFB8
CKM_SKIPJACK_ECB64
lib/Crypt/Cryptoki/Constant.pm view on Meta::CPAN
CKM_TLS_KEY_AND_MAC_DERIVE
CKM_TLS_MASTER_KEY_DERIVE
CKM_TLS_MASTER_KEY_DERIVE_DH
CKM_TLS_PRE_MASTER_KEY_GEN
CKM_TLS_PRF
CKM_TWOFISH_CBC
CKM_TWOFISH_KEY_GEN
CKM_VENDOR_DEFINED
CKM_WTLS_CLIENT_KEY_AND_MAC_DERIVE
CKM_WTLS_MASTER_KEY_DERIVE
CKM_WTLS_MASTER_KEY_DERIVE_DH_ECC
Crypt-DES
view release on metacpan or search on metacpan
use Crypt::DES;
=head1 DESCRIPTION
The module implements the Crypt::CBC interface,
which has the following methods
=over 4
=item blocksize
=head1 NOTES
Do note that DES only uses 8 byte keys and only works on 8 byte data
blocks. If you're intending to encrypt larger blocks or entire files,
please use Crypt::CBC in conjunction with this module. See the
Crypt::CBC documentation for proper syntax and use.
Also note that the DES algorithm is, by today's standard, weak
encryption. Crypt::Blowfish is highly recommended if you're
interested in using strong encryption and a faster algorithm.
Crypt-DES_EDE3
view release on metacpan or search on metacpan
lib/Crypt/DES_EDE3.pm view on Meta::CPAN
DES-EDE3 encryption requires a key size of 24 bytes.
You're probably best off not using this module directly, as the I<encrypt>
and I<decrypt> methods expect 8-octet blocks. You might want to use the
module in conjunction with I<Crypt::CBC>, for example. This would be
DES-EDE3-CBC, or triple-DES in outer CBC mode.
=head1 USAGE
=head2 $ede3 = Crypt::DES_EDE3->new($key)
( run in 1.726 second using v1.01-cache-2.11-cpan-e1769b4cff6 )