Imported Upstream version 0.048
This commit is contained in:
Mario Fetka
commit
8a5223aec1
|
|
@ -0,0 +1,249 @@
|
|||
Changes for CryptX
|
||||
|
||||
TODO:
|
||||
- add support for PKCS#8 encrypted RSA+ECC private keys "-----BEGIN ENCRYPTED PRIVATE KEY-----"
|
||||
- RSA|DSA|ECC: verify_key($level) (basic check + extented primality test)
|
||||
- better primality testing: http://questhub.io/realm/perl/quest/519032ee1088c76505000035 (idea: mp_prime_lucas)
|
||||
- DSA: generate_key($p, $q, $g), generate_key(\$dsa_params_der), generate_key($dsa_params_file)
|
||||
- XS croaks should report the "real caller" (Crypt::Mac::*, Crypt::Mode::*, ...)
|
||||
- maybe: add CCM interface for new-add-add-done mode
|
||||
- maybe: add encode_b32/decode_b32
|
||||
|
||||
0.048 2017/05/31
|
||||
- NEW: Crypt::Digest::SHA3_224
|
||||
- NEW: Crypt::Digest::SHA3_256
|
||||
- NEW: Crypt::Digest::SHA3_384
|
||||
- NEW: Crypt::Digest::SHA3_512
|
||||
- NEW: Crypt::Digest::SHAKE
|
||||
- NEW: Crypt::Digest::BLAKE2b_160
|
||||
- NEW: Crypt::Digest::BLAKE2b_256
|
||||
- NEW: Crypt::Digest::BLAKE2b_384
|
||||
- NEW: Crypt::Digest::BLAKE2b_512
|
||||
- NEW: Crypt::Digest::BLAKE2s_128
|
||||
- NEW: Crypt::Digest::BLAKE2s_160
|
||||
- NEW: Crypt::Digest::BLAKE2s_224
|
||||
- NEW: Crypt::Digest::BLAKE2s_256
|
||||
- NEW: Crypt::AuthEnc::ChaCha20Poly1305
|
||||
- NEW: Crypt::Mac::Poly1305
|
||||
- NEW: Crypt::Mac::BLAKE2s
|
||||
- NEW: Crypt::Mac::BLAKE2b
|
||||
- NEW: Crypt::PRNG::ChaCha20
|
||||
- NEW: Crypt::Stream::ChaCha
|
||||
- NEW: Crypt::Stream::RC4
|
||||
- NEW: Crypt::Stream::Sober128
|
||||
- NEW: functions in Crypt::Misc - increment_octets_be, increment_octets_le
|
||||
- Crypt::PRNG now uses chacha20 prng by default
|
||||
|
||||
0.047 2017/04/05
|
||||
- fix #32 Compile "ar" step fails when Perl built with -flto (better version)
|
||||
- fix #33 build fails on freebsd 9.2 and 10.0 (ar: fatal: Numeric group ID too large)
|
||||
|
||||
0.046 2017/04/04
|
||||
- fix #32 Compile "ar" step fails when Perl built with -flto
|
||||
|
||||
0.045 2017/03/31
|
||||
- sync with libtomcrypt/develop
|
||||
- fix #30 fix on SPARC+SolarisStudio
|
||||
- fix #31 Fails tests without '.' in @INC
|
||||
- polish compiler warnings
|
||||
|
||||
0.044 2016/11/28
|
||||
- fix #27 Math::BigInt::LTM compatibility with older Math::BigInt
|
||||
|
||||
0.043 2016/11/27
|
||||
- fix #26 Math::BigInt::LTM compatibility with Math::BigInt 1.999801+
|
||||
|
||||
0.042 2016/11/12
|
||||
- RSA: sign/verify functions now support 'none' padding (INSECURE!)
|
||||
- RC2: min keylen 40bit, used to be 64bit (INSECURE!)
|
||||
|
||||
0.041 2016/10/12
|
||||
- ECC: ltc_ecc_is_point memory leak
|
||||
- DSA: properly handle FIPS 186-4 (4.6 + 4.7)
|
||||
- GCM: counter incrementation isn't stopped at 2^32 blocks, which breaks GCM
|
||||
- fix issue #24 Crypt::PK::ECC needs $VERSION (all *.pm have $VERSION)
|
||||
|
||||
0.040 2016/09/12
|
||||
- fix file permissions
|
||||
- fix compiler warnings
|
||||
|
||||
0.039 2016/08/02
|
||||
- fix build troubles for MacOS / PPC
|
||||
|
||||
0.038 2016/07/06
|
||||
- fix issue #20 DSA/RSA/ECC/DH key2hash - hexadecimal numbers are missing leading zero
|
||||
- Math::BigInt::LTM fixed mp_invmod(a,b,c) for b == 1
|
||||
- Math::BigInt::LTM fixed _log_int()
|
||||
- Math::BigInt::LTM fixed _alen()
|
||||
- fix 'Please specify prototyping behavior for CryptX.xs'
|
||||
- libtomcrypt (renaming *tab.c > *tab.c.inc not needed anymore)
|
||||
|
||||
0.037 2016/06/16
|
||||
- fix issue #18 Minor issue with comment syntax
|
||||
- fix issue #19 t/checksum.t fails on AIX-5.3
|
||||
|
||||
0.036 2016/06/07
|
||||
- fix issue #17 ability to export ecc keys in short/oid form
|
||||
|
||||
0.035 2016/06/03
|
||||
- fix issue #14 Ensure Crypt::PK::ECC->key2hash()->{curve_name} is lowercase
|
||||
- fix issue #15 OpenSSL interoperability broken
|
||||
|
||||
0.034 2016/05/11
|
||||
- Prevent RSA import_key() from altering a JWK hash reference
|
||||
|
||||
0.033 2016/05/09
|
||||
- MSVC6 related fixes (needed for older ActivePerl@MSWin32)
|
||||
|
||||
0.032 2016/05/04
|
||||
- Crypt::PK::DH - accept base/prime values
|
||||
- new: DH methods export_key_raw, import_key_raw, params2hash
|
||||
- enhanced: DH method generate_key
|
||||
- new: Crypt::Checksum, Crypt::Checksum::CRC32, Crypt::Checksum::Adler32
|
||||
|
||||
0.031 2016/05/01
|
||||
- new: RSA+ECC method export_key_jwk_thumbprint()
|
||||
- new: Crypt::Misc functions random_v4uuid + is_v4uuid
|
||||
- fix: RSA+ECC export_key_jwk produces canonical JSON
|
||||
- fix: RSA+DSA public key export now produces PEM/DER compatible with openssl
|
||||
public keys exported be previous version can still be imported
|
||||
- fix: ECC import_key now accepts non-standard JWK curve names e.g. "secp112r1", "secp521r1"
|
||||
|
||||
0.030 2016/04/13
|
||||
- fix: 0.029 + 0.028 by mistake installed *.inc files to perl/(lib|site|vendor)
|
||||
|
||||
0.029 2016/04/13
|
||||
- NEW module: Math::BigInt::LTM
|
||||
- NEW module: Crypt::Misc
|
||||
|
||||
0.028 2016/03/23
|
||||
- IMPORTANT: switch from Module::Build to ExtUtils::MakeMaker
|
||||
- fix for broken DSA key (ssh format) loading
|
||||
|
||||
0.027 2016/01/25
|
||||
- sync with https://github.com/libtom/libtomcrypt (branch develop)
|
||||
- sync with https://github.com/libtom/libtommath (branch develop)
|
||||
- HP-UX related fixes
|
||||
- JSON dependency is now optional (we check JSON::PP, JSON::XS, Cpanel::JSON::XS)
|
||||
- skip jwk.t if no JSON::* module available
|
||||
- does not require MIME::Base64 (we use base64 routines from libtomcrypt)
|
||||
|
||||
0.026 2015/11/28
|
||||
- switch to JSON::MaybeXS
|
||||
- Crypt::PRNG - rand/irand related cosmetics
|
||||
- consistently using UNIX newlines
|
||||
|
||||
0.025 2015/07/07
|
||||
- Crypt::PK::ECC+RSA export_key_jwk() allows to export a perl HASH with JWK structure
|
||||
|
||||
0.024 2015/06/29
|
||||
- new Crypt::PK::ECC methods
|
||||
verify_message_rfc7518()
|
||||
sign_message_rfc7518()
|
||||
curve2hash()
|
||||
- fix for Crypt::PK::RSA - bug in loading private key in JWK format
|
||||
|
||||
0.023 2015/06/10
|
||||
- support for older compilers (gcc3, vc6)
|
||||
- typo in documentation (by tomhukins)
|
||||
|
||||
0.022 2015/05/22
|
||||
- new: Crypt::PK::ECC+RSA export_key_jwk() - exporting JWK format
|
||||
- new: Crypt::Digest::SHA512_224
|
||||
- new: Crypt::Digest::SHA512_256
|
||||
- Crypt::PK::ECC+RSA import_key() - support for:
|
||||
* public/private keys in JWK format
|
||||
* private keys in PKCS8 PEM/DER format (unencrypted only)
|
||||
- Crypt::PK::ECC+RSA+DSA import_key() - support for:
|
||||
* public keys in SSH format
|
||||
* public/private keys as a hashref exported via key2hash
|
||||
- libtomcrypt updated to the latest develop branch, commit aeaa6d4a51 Apr 17 08:59:35 2015 +0200
|
||||
- libtommath updated to the latest develop branch, commit 0fd5e6c17f Dec 11 14:59:35 2014 +0100
|
||||
- documentation fixes
|
||||
|
||||
0.021 2014/01/23
|
||||
- fixed asm(...) related compiler failures
|
||||
- dsa_encrypt_key small correction
|
||||
- optimized ecc_encrypt_key
|
||||
|
||||
0.020 2014/01/18
|
||||
- INCOMPATIBLE CHANGE: huge redesign of Crypt::PK::ECC
|
||||
- ECC now supports curves y^2 = x^3 + a*x + b
|
||||
- ECC you can use custom curves
|
||||
- ECC import/export of keys in DER/PEM format now compatible with openssl
|
||||
- enabling compile options ASM + ECC_TIMING_RESISTANT
|
||||
- added many test vectors (RSA, DSA, EC) for interoperability with openssl
|
||||
|
||||
0.019 2013/10/20
|
||||
- fixed broken CAMELLIA implementation
|
||||
|
||||
0.018 2013/10/18
|
||||
- DSA: make_key + sign_hash fixes
|
||||
|
||||
0.017 2013/09/24
|
||||
- lowering MIME::Base64 version requirement
|
||||
- support for import/export of password protected RSA/DSA keys
|
||||
- RSA: added - export_key_pem('public_x509')
|
||||
- better handling of dh_free/rsa_free/dsa_free/ecc_free
|
||||
- added openssl test vectors
|
||||
- fixed compiler warnings (RSA/DSA/ECC/DH)
|
||||
|
||||
0.016 2013/09/15
|
||||
- added missing test for key2hash, sign_hash, verify_hash
|
||||
- fixed build failures on VC6
|
||||
|
||||
0.015 2013/09/12
|
||||
- only documentation fixes
|
||||
|
||||
0.014 2013/09/11
|
||||
- Crypt::Digest::NNN + Crypt::Mac::NNN - can produce Base64-URL-Safe encoded digest/mac
|
||||
- Crypt::PRNG + Crypt::PRNG::NNN - Base64-URL-Safe encoded random bytes (random_bytes_b64u/bytes_b64u)
|
||||
- Crypt::PK::RSA/DSA/DH/ECC - sign/verify replaced by sign_message/verify_message + sign_hash/verify_hash
|
||||
- Crypt::PK::RSA/DSA/DH/ECC - new method key2hash
|
||||
- documentation fixes
|
||||
|
||||
0.013 2013/08/28
|
||||
- DSA/RSA/ECC/DH - importing keys from string changed - now: $pk->import_key(\$buffer_with_key)
|
||||
- DSA/RSA/ECC/DH - size() and is_private() now return undef if no key loaded
|
||||
- improved RSA doc
|
||||
|
||||
0.012 2013/06/17
|
||||
- README, LICENSE etc. to improve CPANTS score
|
||||
- somehow works with perl 5.6.2
|
||||
|
||||
0.011 2013/06/15
|
||||
- fixing various compiler warnings
|
||||
|
||||
0.009 2013/05/19
|
||||
- doc fixes
|
||||
- requires perl 5.8.8 or higher
|
||||
- INCOMPATIBILITY: all digest related 'xxx_base64' functions renamed to 'xxx_b64'
|
||||
|
||||
0.008 2013/05/02
|
||||
- fixed prng test failures
|
||||
- Crypt::Digest::* croaks with the "real caller" (not a nice solution)
|
||||
|
||||
0.007 2013/04/23
|
||||
- Crypt::PRNG supports add_entropy() - without params
|
||||
- Crypt::PRNG fork-safe & thread-safe
|
||||
- random_string has default $len = 20
|
||||
- doc fixes
|
||||
- cpan tester failure fix for pk_dsa.t
|
||||
|
||||
0.006 2013/04/19
|
||||
- added Crypt::KeyDerivation
|
||||
- Win64 compatibility
|
||||
|
||||
0.005 2013/04/18
|
||||
- added Crypt::PRNG::Fortuna|RC4|Sober128|Yarrow
|
||||
- added Crypt::PK::RSA|DSA|ECC|DH
|
||||
|
||||
0.004 2013/04/16
|
||||
- removing illegal Crypt::Random
|
||||
|
||||
0.003 2013/04/16
|
||||
- added Crypt::Mode::CBC|CFB|CTR|ECB|OFB
|
||||
- added Crypt::AuthEnc::CCM|EAX|GCM|OCB
|
||||
|
||||
0.002 2013/04/11
|
||||
- first release on CPAN
|
||||
|
|
@ -0,0 +1,580 @@
|
|||
#include "EXTERN.h"
|
||||
#include "perl.h"
|
||||
#include "XSUB.h"
|
||||
|
||||
#define NEED_sv_2pvbyte_GLOBAL
|
||||
#define NEED_sv_2pv_flags_GLOBAL
|
||||
#define NEED_newRV_noinc_GLOBAL
|
||||
#include "ppport.h"
|
||||
|
||||
#undef LTC_SOURCE
|
||||
#include "tomcrypt.h"
|
||||
#include "tommath.h"
|
||||
|
||||
typedef adler32_state *Crypt__Checksum__Adler32;
|
||||
typedef crc32_state *Crypt__Checksum__CRC32;
|
||||
|
||||
typedef struct cipher_struct { /* used by Crypt::Cipher */
|
||||
symmetric_key skey;
|
||||
int id;
|
||||
struct ltc_cipher_descriptor *desc;
|
||||
} *Crypt__Cipher;
|
||||
|
||||
typedef struct digest_struct { /* used by Crypt::Digest */
|
||||
hash_state state;
|
||||
int id;
|
||||
struct ltc_hash_descriptor *desc;
|
||||
} *Crypt__Digest;
|
||||
|
||||
typedef struct digest_shake_struct { /* used by Crypt::Digest::SHAKE */
|
||||
hash_state state;
|
||||
int num;
|
||||
} *Crypt__Digest__SHAKE;
|
||||
|
||||
typedef struct ccm_struct { /* used by Crypt::AuthEnc::CCM */
|
||||
ccm_state state;
|
||||
int id;
|
||||
} *Crypt__AuthEnc__CCM;
|
||||
|
||||
typedef struct eax_struct { /* used by Crypt::AuthEnc::EAX */
|
||||
eax_state state;
|
||||
int id;
|
||||
} *Crypt__AuthEnc__EAX;
|
||||
|
||||
typedef struct gcm_struct { /* used by Crypt::AuthEnc::GCM */
|
||||
gcm_state state;
|
||||
int id;
|
||||
} *Crypt__AuthEnc__GCM;
|
||||
|
||||
typedef struct chacha20poly1305_struct {/* used by Crypt::AuthEnc::ChaCha20Poly1305 */
|
||||
chacha20poly1305_state state;
|
||||
int id;
|
||||
} *Crypt__AuthEnc__ChaCha20Poly1305;
|
||||
|
||||
typedef struct ocb_struct { /* used by Crypt::AuthEnc::OCB */
|
||||
ocb3_state state;
|
||||
int id;
|
||||
} *Crypt__AuthEnc__OCB;
|
||||
|
||||
typedef struct chacha_struct { /* used by Crypt::Stream::ChaCha */
|
||||
chacha_state state;
|
||||
int id;
|
||||
} *Crypt__Stream__ChaCha;
|
||||
|
||||
typedef struct rc4_struct { /* used by Crypt::Stream::RC4 */
|
||||
rc4_state state;
|
||||
int id;
|
||||
} *Crypt__Stream__RC4;
|
||||
|
||||
typedef struct sober128_struct { /* used by Crypt::Stream::Sober128 */
|
||||
sober128_state state;
|
||||
int id;
|
||||
} *Crypt__Stream__Sober128;
|
||||
|
||||
typedef struct f9_struct { /* used by Crypt::Mac::F9 */
|
||||
f9_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__F9;
|
||||
|
||||
typedef struct hmac_struct { /* used by Crypt::Mac::HMAC */
|
||||
hmac_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__HMAC;
|
||||
|
||||
typedef struct omac_struct { /* used by Crypt::Mac::OMAC */
|
||||
omac_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__OMAC;
|
||||
|
||||
typedef struct pelican_struct { /* used by Crypt::Mac::Pelican */
|
||||
pelican_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__Pelican;
|
||||
|
||||
typedef struct pmac_struct { /* used by Crypt::Mac::PMAC */
|
||||
pmac_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__PMAC;
|
||||
|
||||
typedef struct xcbc_struct { /* used by Crypt::Mac::XCBC */
|
||||
xcbc_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__XCBC;
|
||||
|
||||
typedef struct poly1305_struct { /* used by Crypt::Mac::Poly1305 */
|
||||
poly1305_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__Poly1305;
|
||||
|
||||
typedef struct blake2s_struct { /* used by Crypt::Mac::BLAKE2s */
|
||||
blake2smac_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__BLAKE2s;
|
||||
|
||||
typedef struct blake2b_struct { /* used by Crypt::Mac::BLAKE2b */
|
||||
blake2bmac_state state;
|
||||
int id;
|
||||
} *Crypt__Mac__BLAKE2b;
|
||||
|
||||
typedef struct cbc_struct { /* used by Crypt::Mode::CBC */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_CBC state;
|
||||
unsigned char pad[MAXBLOCKSIZE];
|
||||
int padlen;
|
||||
int padding_mode;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__CBC;
|
||||
|
||||
typedef struct ecb_struct { /* used by Crypt::Mode::ECB */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_ECB state;
|
||||
unsigned char pad[MAXBLOCKSIZE];
|
||||
int padlen;
|
||||
int padding_mode;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__ECB;
|
||||
|
||||
typedef struct cfb_struct { /* used by Crypt::Mode::CFB */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_CFB state;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__CFB;
|
||||
|
||||
typedef struct ctr_struct { /* used by Crypt::Mode::CTR */
|
||||
int cipher_id, cipher_rounds;
|
||||
int ctr_mode_param;
|
||||
symmetric_CTR state;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__CTR;
|
||||
|
||||
typedef struct f8_struct { /* used by Crypt::Mode::F8 */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_F8 state;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__F8;
|
||||
|
||||
typedef struct lrw_struct { /* used by Crypt::Mode::LRW */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_LRW state;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__LRW;
|
||||
|
||||
typedef struct ofb_struct { /* used by Crypt::Mode::OFB */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_OFB state;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__OFB;
|
||||
|
||||
typedef struct xts_struct { /* used by Crypt::Mode::XTS */
|
||||
int cipher_id, cipher_rounds;
|
||||
symmetric_xts state;
|
||||
int direction;
|
||||
int id;
|
||||
} *Crypt__Mode__XTS;
|
||||
|
||||
typedef struct prng_struct { /* used by Crypt::PRNG */
|
||||
prng_state state;
|
||||
struct ltc_prng_descriptor *desc;
|
||||
IV last_pid;
|
||||
int id;
|
||||
} *Crypt__PRNG;
|
||||
|
||||
typedef struct rsa_struct { /* used by Crypt::PK::RSA */
|
||||
prng_state pstate;
|
||||
int pindex;
|
||||
rsa_key key;
|
||||
int id;
|
||||
} *Crypt__PK__RSA;
|
||||
|
||||
typedef struct dsa_struct { /* used by Crypt::PK::DSA */
|
||||
prng_state pstate;
|
||||
int pindex;
|
||||
dsa_key key;
|
||||
int id;
|
||||
} *Crypt__PK__DSA;
|
||||
|
||||
typedef struct dh_struct { /* used by Crypt::PK::DH */
|
||||
prng_state pstate;
|
||||
int pindex;
|
||||
dh_key key;
|
||||
int id;
|
||||
} *Crypt__PK__DH;
|
||||
|
||||
typedef struct ecc_struct { /* used by Crypt::PK::ECC */
|
||||
prng_state pstate;
|
||||
int pindex;
|
||||
ecc_key key;
|
||||
ltc_ecc_set_type dp;
|
||||
int id;
|
||||
} *Crypt__PK__ECC;
|
||||
|
||||
int str_add_leading_zero(char *str, int maxlen, int minlen) {
|
||||
int len;
|
||||
len = (int)strlen(str);
|
||||
if (len > 0 && len % 2 && len < maxlen-2) {
|
||||
memmove(str+1, str, len+1); /* incl. NUL byte */
|
||||
*str = '0'; /* add leading zero */
|
||||
}
|
||||
len = (int)strlen(str);
|
||||
if (len < minlen && minlen < maxlen-1) {
|
||||
memmove(str+(minlen-len), str, len+1); /* incl. NUL byte */
|
||||
memset(str, '0', minlen-len); /* add leading zero */
|
||||
}
|
||||
return MP_OKAY;
|
||||
}
|
||||
|
||||
int mp_tohex_with_leading_zero(mp_int * a, char *str, int maxlen, int minlen) {
|
||||
int rv;
|
||||
if (mp_isneg(a) == MP_YES) {
|
||||
*str = '\0';
|
||||
return MP_VAL;
|
||||
}
|
||||
rv = mp_toradix_n(a, str, 16, maxlen);
|
||||
if (rv != MP_OKAY) {
|
||||
*str = '\0';
|
||||
return rv;
|
||||
}
|
||||
return str_add_leading_zero(str, maxlen, minlen);
|
||||
}
|
||||
|
||||
/* Math::BigInt::LTM related */
|
||||
typedef mp_int * Math__BigInt__LTM;
|
||||
STATIC SV * sv_from_mpi(mp_int *mpi) {
|
||||
SV *obj = newSV(0);
|
||||
sv_setref_pv(obj, "Math::BigInt::LTM", (void*)mpi);
|
||||
return obj;
|
||||
}
|
||||
|
||||
ltc_ecc_set_type* _ecc_set_dp_from_SV(ltc_ecc_set_type *dp, SV *curve)
|
||||
{
|
||||
HV *h;
|
||||
SV *param, **pref;
|
||||
SV **sv_cofactor, **sv_prime, **sv_A, **sv_B, **sv_order, **sv_Gx, **sv_Gy;
|
||||
int err;
|
||||
char *ch_name;
|
||||
STRLEN l_name;
|
||||
|
||||
if (SvPOK(curve)) {
|
||||
ch_name = SvPV(curve, l_name);
|
||||
if ((h = get_hv("Crypt::PK::ECC::curve", 0)) == NULL) croak("FATAL: generate_key_ex: no curve register");
|
||||
if ((pref = hv_fetch(h, ch_name, (U32)l_name, 0)) == NULL) croak("FATAL: generate_key_ex: unknown curve/1 '%s'", ch_name);
|
||||
if (!SvOK(*pref)) croak("FATAL: generate_key_ex: unknown curve/2 '%s'", ch_name);
|
||||
param = *pref;
|
||||
}
|
||||
else if (SvROK(curve)) {
|
||||
param = curve;
|
||||
}
|
||||
else {
|
||||
croak("FATAL: curve has to be a string or a hashref");
|
||||
}
|
||||
|
||||
if ((h = (HV*)(SvRV(param))) == NULL) croak("FATAL: ecparams: param is not valid hashref");
|
||||
|
||||
if ((sv_prime = hv_fetchs(h, "prime", 0)) == NULL) croak("FATAL: ecparams: missing param prime");
|
||||
if ((sv_A = hv_fetchs(h, "A", 0)) == NULL) croak("FATAL: ecparams: missing param A");
|
||||
if ((sv_B = hv_fetchs(h, "B", 0)) == NULL) croak("FATAL: ecparams: missing param B");
|
||||
if ((sv_order = hv_fetchs(h, "order", 0)) == NULL) croak("FATAL: ecparams: missing param order");
|
||||
if ((sv_Gx = hv_fetchs(h, "Gx", 0)) == NULL) croak("FATAL: ecparams: missing param Gx");
|
||||
if ((sv_Gy = hv_fetchs(h, "Gy", 0)) == NULL) croak("FATAL: ecparams: missing param Gy");
|
||||
if ((sv_cofactor = hv_fetchs(h, "cofactor", 0)) == NULL) croak("FATAL: ecparams: missing param cofactor");
|
||||
|
||||
if (!SvOK(*sv_prime )) croak("FATAL: ecparams: undefined param prime");
|
||||
if (!SvOK(*sv_A )) croak("FATAL: ecparams: undefined param A");
|
||||
if (!SvOK(*sv_B )) croak("FATAL: ecparams: undefined param B");
|
||||
if (!SvOK(*sv_order )) croak("FATAL: ecparams: undefined param order");
|
||||
if (!SvOK(*sv_Gx )) croak("FATAL: ecparams: undefined param Gx");
|
||||
if (!SvOK(*sv_Gy )) croak("FATAL: ecparams: undefined param Gy");
|
||||
if (!SvOK(*sv_cofactor)) croak("FATAL: ecparams: undefined param cofactor");
|
||||
|
||||
err = ecc_dp_set( dp,
|
||||
SvPV_nolen(*sv_prime),
|
||||
SvPV_nolen(*sv_A),
|
||||
SvPV_nolen(*sv_B),
|
||||
SvPV_nolen(*sv_order),
|
||||
SvPV_nolen(*sv_Gx),
|
||||
SvPV_nolen(*sv_Gy),
|
||||
(unsigned long)SvUV(*sv_cofactor),
|
||||
NULL, /* we intentionally don't allow setting custom names */
|
||||
NULL /* we intentionally don't allow setting custom OIDs */
|
||||
);
|
||||
return err == CRYPT_OK ? dp : NULL;
|
||||
}
|
||||
|
||||
void _ecc_free_key(ecc_key *key, ltc_ecc_set_type *dp)
|
||||
{
|
||||
if(dp) {
|
||||
ecc_dp_clear(dp);
|
||||
}
|
||||
if (key->type != -1) {
|
||||
ecc_free(key);
|
||||
key->type = -1;
|
||||
key->dp = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
MODULE = CryptX PACKAGE = CryptX PREFIX = CryptX_
|
||||
|
||||
PROTOTYPES: DISABLE
|
||||
|
||||
BOOT:
|
||||
if(register_cipher(&blowfish_desc)==-1) { croak("FATAL: cannot register_cipher blowfish"); }
|
||||
if(register_cipher(&rc5_desc)==-1) { croak("FATAL: cannot register_cipher rc5"); }
|
||||
if(register_cipher(&rc6_desc)==-1) { croak("FATAL: cannot register_cipher rc6"); }
|
||||
if(register_cipher(&rc2_desc)==-1) { croak("FATAL: cannot register_cipher rc2"); }
|
||||
if(register_cipher(&saferp_desc)==-1) { croak("FATAL: cannot register_cipher saferp"); }
|
||||
if(register_cipher(&safer_k64_desc)==-1) { croak("FATAL: cannot register_cipher safer_k64"); }
|
||||
if(register_cipher(&safer_k128_desc)==-1) { croak("FATAL: cannot register_cipher safer_k128"); }
|
||||
if(register_cipher(&safer_sk64_desc)==-1) { croak("FATAL: cannot register_cipher safer_sk64"); }
|
||||
if(register_cipher(&safer_sk128_desc)==-1) { croak("FATAL: cannot register_cipher safer_sk128"); }
|
||||
if(register_cipher(&aes_desc)==-1) { croak("FATAL: cannot register_cipher aes"); }
|
||||
if(register_cipher(&xtea_desc)==-1) { croak("FATAL: cannot register_cipher xtea"); }
|
||||
if(register_cipher(&twofish_desc)==-1) { croak("FATAL: cannot register_cipher twofish"); }
|
||||
if(register_cipher(&des_desc)==-1) { croak("FATAL: cannot register_cipher des"); }
|
||||
if(register_cipher(&des3_desc)==-1) { croak("FATAL: cannot register_cipher des3"); }
|
||||
if(register_cipher(&cast5_desc)==-1) { croak("FATAL: cannot register_cipher cast5"); }
|
||||
if(register_cipher(&noekeon_desc)==-1) { croak("FATAL: cannot register_cipher noekeon"); }
|
||||
if(register_cipher(&skipjack_desc)==-1) { croak("FATAL: cannot register_cipher skipjack"); }
|
||||
if(register_cipher(&khazad_desc)==-1) { croak("FATAL: cannot register_cipher khazad"); }
|
||||
if(register_cipher(&anubis_desc)==-1) { croak("FATAL: cannot register_cipher anubis"); }
|
||||
if(register_cipher(&kseed_desc)==-1) { croak("FATAL: cannot register_cipher kseed"); }
|
||||
if(register_cipher(&kasumi_desc)==-1) { croak("FATAL: cannot register_cipher kasumi"); }
|
||||
if(register_cipher(&multi2_desc)==-1) { croak("FATAL: cannot register_cipher multi2"); }
|
||||
if(register_cipher(&camellia_desc)==-1) { croak("FATAL: cannot register_cipher camellia"); }
|
||||
/* --- */
|
||||
if(register_hash(&chc_desc)==-1) { croak("FATAL: cannot register_hash chc_hash"); }
|
||||
if(register_hash(&md2_desc)==-1) { croak("FATAL: cannot register_hash md2"); }
|
||||
if(register_hash(&md4_desc)==-1) { croak("FATAL: cannot register_hash md4"); }
|
||||
if(register_hash(&md5_desc)==-1) { croak("FATAL: cannot register_hash md5"); }
|
||||
if(register_hash(&rmd128_desc)==-1) { croak("FATAL: cannot register_hash rmd128"); }
|
||||
if(register_hash(&rmd160_desc)==-1) { croak("FATAL: cannot register_hash rmd160"); }
|
||||
if(register_hash(&rmd256_desc)==-1) { croak("FATAL: cannot register_hash rmd256"); }
|
||||
if(register_hash(&rmd320_desc)==-1) { croak("FATAL: cannot register_hash rmd320"); }
|
||||
if(register_hash(&sha1_desc)==-1) { croak("FATAL: cannot register_hash sha1"); }
|
||||
if(register_hash(&sha224_desc)==-1) { croak("FATAL: cannot register_hash sha224"); }
|
||||
if(register_hash(&sha256_desc)==-1) { croak("FATAL: cannot register_hash sha256"); }
|
||||
if(register_hash(&sha384_desc)==-1) { croak("FATAL: cannot register_hash sha384"); }
|
||||
if(register_hash(&sha512_desc)==-1) { croak("FATAL: cannot register_hash sha512"); }
|
||||
if(register_hash(&sha512_224_desc)==-1) { croak("FATAL: cannot register_hash sha512_224"); }
|
||||
if(register_hash(&sha512_256_desc)==-1) { croak("FATAL: cannot register_hash sha512_256"); }
|
||||
if(register_hash(&sha3_224_desc)==-1) { croak("FATAL: cannot register_hash sha3_224"); }
|
||||
if(register_hash(&sha3_256_desc)==-1) { croak("FATAL: cannot register_hash sha3_256"); }
|
||||
if(register_hash(&sha3_384_desc)==-1) { croak("FATAL: cannot register_hash sha3_384"); }
|
||||
if(register_hash(&sha3_512_desc)==-1) { croak("FATAL: cannot register_hash sha3_512"); }
|
||||
if(register_hash(&tiger_desc)==-1) { croak("FATAL: cannot register_hash tiger"); }
|
||||
if(register_hash(&whirlpool_desc)==-1) { croak("FATAL: cannot register_hash whirlpool"); }
|
||||
if(register_hash(&blake2b_160_desc)==-1) { croak("FATAL: cannot register_hash blake2b_160"); }
|
||||
if(register_hash(&blake2b_256_desc)==-1) { croak("FATAL: cannot register_hash blake2b_256"); }
|
||||
if(register_hash(&blake2b_384_desc)==-1) { croak("FATAL: cannot register_hash blake2b_384"); }
|
||||
if(register_hash(&blake2b_512_desc)==-1) { croak("FATAL: cannot register_hash blake2b_512"); }
|
||||
if(register_hash(&blake2s_128_desc)==-1) { croak("FATAL: cannot register_hash blake2s_128"); }
|
||||
if(register_hash(&blake2s_160_desc)==-1) { croak("FATAL: cannot register_hash blake2s_160"); }
|
||||
if(register_hash(&blake2s_224_desc)==-1) { croak("FATAL: cannot register_hash blake2s_224"); }
|
||||
if(register_hash(&blake2s_256_desc)==-1) { croak("FATAL: cannot register_hash blake2s_256"); }
|
||||
/* --- */
|
||||
if(chc_register(find_cipher("aes"))==-1) { croak("FATAL: chc_register failed"); }
|
||||
/* --- */
|
||||
if(register_prng(&fortuna_desc)==-1) { croak("FATAL: cannot register_prng fortuna"); }
|
||||
if(register_prng(&yarrow_desc)==-1) { croak("FATAL: cannot register_prng yarrow"); }
|
||||
if(register_prng(&rc4_desc)==-1) { croak("FATAL: cannot register_prng rc4"); }
|
||||
if(register_prng(&sober128_desc)==-1) { croak("FATAL: cannot register_prng sober128"); }
|
||||
if(register_prng(&chacha20_prng_desc)==-1) { croak("FATAL: cannot register_prng chacha20"); }
|
||||
/* --- */
|
||||
#ifdef TFM_DESC
|
||||
ltc_mp = tfm_desc;
|
||||
#else
|
||||
ltc_mp = ltm_desc;
|
||||
#endif
|
||||
|
||||
SV *
|
||||
CryptX__encode_base64url(SV * in)
|
||||
CODE:
|
||||
{
|
||||
STRLEN in_len;
|
||||
unsigned long out_len;
|
||||
unsigned char *out_data, *in_data;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(in)) XSRETURN_UNDEF;
|
||||
in_data = (unsigned char *) SvPVbyte(in, in_len);
|
||||
out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
|
||||
Newz(0, out_data, out_len, unsigned char);
|
||||
if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
|
||||
rv = base64url_encode(in_data, (unsigned long)in_len, out_data, &out_len);
|
||||
RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
|
||||
Safefree(out_data);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
CryptX__decode_base64url(SV * in)
|
||||
CODE:
|
||||
{
|
||||
STRLEN in_len;
|
||||
unsigned long out_len;
|
||||
unsigned char *out_data, *in_data;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(in)) XSRETURN_UNDEF;
|
||||
in_data = (unsigned char *) SvPVbyte(in, in_len);
|
||||
out_len = (unsigned long)in_len;
|
||||
Newz(0, out_data, out_len, unsigned char);
|
||||
if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
|
||||
rv = base64url_decode(in_data, (unsigned long)in_len, out_data, &out_len);
|
||||
RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
|
||||
Safefree(out_data);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
CryptX__encode_base64(SV * in)
|
||||
CODE:
|
||||
{
|
||||
STRLEN in_len;
|
||||
unsigned long out_len;
|
||||
unsigned char *out_data, *in_data;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(in)) XSRETURN_UNDEF;
|
||||
in_data = (unsigned char *) SvPVbyte(in, in_len);
|
||||
out_len = (unsigned long)(4 * ((in_len + 2) / 3) + 1);
|
||||
Newz(0, out_data, out_len, unsigned char);
|
||||
if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
|
||||
rv = base64_encode(in_data, (unsigned long)in_len, out_data, &out_len);
|
||||
RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
|
||||
Safefree(out_data);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
CryptX__decode_base64(SV * in)
|
||||
CODE:
|
||||
{
|
||||
STRLEN in_len;
|
||||
unsigned long out_len;
|
||||
unsigned char *out_data, *in_data;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(in)) XSRETURN_UNDEF;
|
||||
in_data = (unsigned char *) SvPVbyte(in, in_len);
|
||||
out_len = (unsigned long)in_len;
|
||||
Newz(0, out_data, out_len, unsigned char);
|
||||
if (!out_data) croak("FATAL: Newz failed [%ld]", out_len);
|
||||
rv = base64_decode(in_data, (unsigned long)in_len, out_data, &out_len);
|
||||
RETVAL = (rv == CRYPT_OK) ? newSVpvn((char *)out_data, out_len) : newSVpvn(NULL, 0);
|
||||
Safefree(out_data);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
CryptX__increment_octets_le(SV * in)
|
||||
CODE:
|
||||
{
|
||||
STRLEN len, i = 0;
|
||||
unsigned char *out_data, *in_data;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(in)) XSRETURN_UNDEF;
|
||||
in_data = (unsigned char *) SvPVbyte(in, len);
|
||||
if (len == 0) XSRETURN_UNDEF;
|
||||
|
||||
RETVAL = NEWSV(0, len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
Copy(in_data, out_data, len, unsigned char);
|
||||
while (i < len) {
|
||||
out_data[i]++;
|
||||
if (0 != out_data[i]) break;
|
||||
i++;
|
||||
}
|
||||
if (i == len) croak("FATAL: increment_octets_le overflow");
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
CryptX__increment_octets_be(SV * in)
|
||||
CODE:
|
||||
{
|
||||
STRLEN len, i = 0;
|
||||
unsigned char *out_data, *in_data;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(in)) XSRETURN_UNDEF;
|
||||
in_data = (unsigned char *) SvPVbyte(in, len);
|
||||
if (len == 0) XSRETURN_UNDEF;
|
||||
|
||||
RETVAL = NEWSV(0, len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
Copy(in_data, out_data, len, unsigned char);
|
||||
while (i < len) {
|
||||
out_data[len - 1 - i]++;
|
||||
if (0 != out_data[len - 1 - i]) break;
|
||||
i++;
|
||||
}
|
||||
if (i == len) croak("FATAL: increment_octets_le overflow");
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
###############################################################################
|
||||
|
||||
INCLUDE: inc/CryptX_Digest.xs.inc
|
||||
INCLUDE: inc/CryptX_Digest_SHAKE.xs.inc
|
||||
INCLUDE: inc/CryptX_Cipher.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_Checksum_Adler32.xs.inc
|
||||
INCLUDE: inc/CryptX_Checksum_CRC32.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_AuthEnc_EAX.xs.inc
|
||||
INCLUDE: inc/CryptX_AuthEnc_GCM.xs.inc
|
||||
INCLUDE: inc/CryptX_AuthEnc_OCB.xs.inc
|
||||
INCLUDE: inc/CryptX_AuthEnc_CCM.xs.inc
|
||||
INCLUDE: inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_Stream_ChaCha.xs.inc
|
||||
INCLUDE: inc/CryptX_Stream_RC4.xs.inc
|
||||
INCLUDE: inc/CryptX_Stream_Sober128.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_Mac_F9.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_HMAC.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_OMAC.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_Pelican.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_PMAC.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_XCBC.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_Poly1305.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_BLAKE2s.xs.inc
|
||||
INCLUDE: inc/CryptX_Mac_BLAKE2b.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_Mode_CBC.xs.inc
|
||||
INCLUDE: inc/CryptX_Mode_ECB.xs.inc
|
||||
INCLUDE: inc/CryptX_Mode_CFB.xs.inc
|
||||
INCLUDE: inc/CryptX_Mode_OFB.xs.inc
|
||||
INCLUDE: inc/CryptX_Mode_CTR.xs.inc
|
||||
#INCLUDE: inc/CryptX_Mode_F8.xs.inc
|
||||
#INCLUDE: inc/CryptX_Mode_LRW.xs.inc
|
||||
#INCLUDE: inc/CryptX_Mode_XTS.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_PRNG.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_PK_RSA.xs.inc
|
||||
INCLUDE: inc/CryptX_PK_DSA.xs.inc
|
||||
INCLUDE: inc/CryptX_PK_DH.xs.inc
|
||||
INCLUDE: inc/CryptX_PK_ECC.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_KeyDerivation.xs.inc
|
||||
|
||||
INCLUDE: inc/CryptX_BigInt_LTM.xs.inc
|
||||
|
|
@ -0,0 +1 @@
|
|||
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
|
||||
|
|
@ -0,0 +1,929 @@
|
|||
Changes
|
||||
CryptX.xs
|
||||
inc/CryptX_AuthEnc_CCM.xs.inc
|
||||
inc/CryptX_AuthEnc_ChaCha20Poly1305.xs.inc
|
||||
inc/CryptX_AuthEnc_EAX.xs.inc
|
||||
inc/CryptX_AuthEnc_GCM.xs.inc
|
||||
inc/CryptX_AuthEnc_OCB.xs.inc
|
||||
inc/CryptX_BigInt_LTM.xs.inc
|
||||
inc/CryptX_Checksum_Adler32.xs.inc
|
||||
inc/CryptX_Checksum_CRC32.xs.inc
|
||||
inc/CryptX_Cipher.xs.inc
|
||||
inc/CryptX_Digest.xs.inc
|
||||
inc/CryptX_Digest_SHAKE.xs.inc
|
||||
inc/CryptX_KeyDerivation.xs.inc
|
||||
inc/CryptX_Mac_BLAKE2b.xs.inc
|
||||
inc/CryptX_Mac_BLAKE2s.xs.inc
|
||||
inc/CryptX_Mac_F9.xs.inc
|
||||
inc/CryptX_Mac_HMAC.xs.inc
|
||||
inc/CryptX_Mac_OMAC.xs.inc
|
||||
inc/CryptX_Mac_Pelican.xs.inc
|
||||
inc/CryptX_Mac_PMAC.xs.inc
|
||||
inc/CryptX_Mac_Poly1305.xs.inc
|
||||
inc/CryptX_Mac_XCBC.xs.inc
|
||||
inc/CryptX_Mode_CBC.xs.inc
|
||||
inc/CryptX_Mode_CFB.xs.inc
|
||||
inc/CryptX_Mode_CTR.xs.inc
|
||||
inc/CryptX_Mode_ECB.xs.inc
|
||||
inc/CryptX_Mode_OFB.xs.inc
|
||||
inc/CryptX_PK_DH.xs.inc
|
||||
inc/CryptX_PK_DSA.xs.inc
|
||||
inc/CryptX_PK_ECC.xs.inc
|
||||
inc/CryptX_PK_RSA.xs.inc
|
||||
inc/CryptX_PRNG.xs.inc
|
||||
inc/CryptX_Stream_ChaCha.xs.inc
|
||||
inc/CryptX_Stream_RC4.xs.inc
|
||||
inc/CryptX_Stream_Sober128.xs.inc
|
||||
lib/Crypt/AuthEnc.pm
|
||||
lib/Crypt/AuthEnc/CCM.pm
|
||||
lib/Crypt/AuthEnc/ChaCha20Poly1305.pm
|
||||
lib/Crypt/AuthEnc/EAX.pm
|
||||
lib/Crypt/AuthEnc/GCM.pm
|
||||
lib/Crypt/AuthEnc/OCB.pm
|
||||
lib/Crypt/Checksum.pm
|
||||
lib/Crypt/Checksum/Adler32.pm
|
||||
lib/Crypt/Checksum/CRC32.pm
|
||||
lib/Crypt/Cipher.pm
|
||||
lib/Crypt/Cipher/AES.pm
|
||||
lib/Crypt/Cipher/Anubis.pm
|
||||
lib/Crypt/Cipher/Blowfish.pm
|
||||
lib/Crypt/Cipher/Camellia.pm
|
||||
lib/Crypt/Cipher/CAST5.pm
|
||||
lib/Crypt/Cipher/DES.pm
|
||||
lib/Crypt/Cipher/DES_EDE.pm
|
||||
lib/Crypt/Cipher/KASUMI.pm
|
||||
lib/Crypt/Cipher/Khazad.pm
|
||||
lib/Crypt/Cipher/MULTI2.pm
|
||||
lib/Crypt/Cipher/Noekeon.pm
|
||||
lib/Crypt/Cipher/RC2.pm
|
||||
lib/Crypt/Cipher/RC5.pm
|
||||
lib/Crypt/Cipher/RC6.pm
|
||||
lib/Crypt/Cipher/SAFER_K128.pm
|
||||
lib/Crypt/Cipher/SAFER_K64.pm
|
||||
lib/Crypt/Cipher/SAFER_SK128.pm
|
||||
lib/Crypt/Cipher/SAFER_SK64.pm
|
||||
lib/Crypt/Cipher/SAFERP.pm
|
||||
lib/Crypt/Cipher/SEED.pm
|
||||
lib/Crypt/Cipher/Skipjack.pm
|
||||
lib/Crypt/Cipher/Twofish.pm
|
||||
lib/Crypt/Cipher/XTEA.pm
|
||||
lib/Crypt/Digest.pm
|
||||
lib/Crypt/Digest/BLAKE2b_160.pm
|
||||
lib/Crypt/Digest/BLAKE2b_256.pm
|
||||
lib/Crypt/Digest/BLAKE2b_384.pm
|
||||
lib/Crypt/Digest/BLAKE2b_512.pm
|
||||
lib/Crypt/Digest/BLAKE2s_128.pm
|
||||
lib/Crypt/Digest/BLAKE2s_160.pm
|
||||
lib/Crypt/Digest/BLAKE2s_224.pm
|
||||
lib/Crypt/Digest/BLAKE2s_256.pm
|
||||
lib/Crypt/Digest/CHAES.pm
|
||||
lib/Crypt/Digest/MD2.pm
|
||||
lib/Crypt/Digest/MD4.pm
|
||||
lib/Crypt/Digest/MD5.pm
|
||||
lib/Crypt/Digest/RIPEMD128.pm
|
||||
lib/Crypt/Digest/RIPEMD160.pm
|
||||
lib/Crypt/Digest/RIPEMD256.pm
|
||||
lib/Crypt/Digest/RIPEMD320.pm
|
||||
lib/Crypt/Digest/SHA1.pm
|
||||
lib/Crypt/Digest/SHA224.pm
|
||||
lib/Crypt/Digest/SHA256.pm
|
||||
lib/Crypt/Digest/SHA384.pm
|
||||
lib/Crypt/Digest/SHA3_224.pm
|
||||
lib/Crypt/Digest/SHA3_256.pm
|
||||
lib/Crypt/Digest/SHA3_384.pm
|
||||
lib/Crypt/Digest/SHA3_512.pm
|
||||
lib/Crypt/Digest/SHA512.pm
|
||||
lib/Crypt/Digest/SHA512_224.pm
|
||||
lib/Crypt/Digest/SHA512_256.pm
|
||||
lib/Crypt/Digest/SHAKE.pm
|
||||
lib/Crypt/Digest/Tiger192.pm
|
||||
lib/Crypt/Digest/Whirlpool.pm
|
||||
lib/Crypt/KeyDerivation.pm
|
||||
lib/Crypt/Mac.pm
|
||||
lib/Crypt/Mac/BLAKE2b.pm
|
||||
lib/Crypt/Mac/BLAKE2s.pm
|
||||
lib/Crypt/Mac/F9.pm
|
||||
lib/Crypt/Mac/HMAC.pm
|
||||
lib/Crypt/Mac/OMAC.pm
|
||||
lib/Crypt/Mac/Pelican.pm
|
||||
lib/Crypt/Mac/PMAC.pm
|
||||
lib/Crypt/Mac/Poly1305.pm
|
||||
lib/Crypt/Mac/XCBC.pm
|
||||
lib/Crypt/Misc.pm
|
||||
lib/Crypt/Mode.pm
|
||||
lib/Crypt/Mode/CBC.pm
|
||||
lib/Crypt/Mode/CFB.pm
|
||||
lib/Crypt/Mode/CTR.pm
|
||||
lib/Crypt/Mode/ECB.pm
|
||||
lib/Crypt/Mode/OFB.pm
|
||||
lib/Crypt/PK.pm
|
||||
lib/Crypt/PK/DH.pm
|
||||
lib/Crypt/PK/DSA.pm
|
||||
lib/Crypt/PK/ECC.pm
|
||||
lib/Crypt/PK/RSA.pm
|
||||
lib/Crypt/PRNG.pm
|
||||
lib/Crypt/PRNG/ChaCha20.pm
|
||||
lib/Crypt/PRNG/Fortuna.pm
|
||||
lib/Crypt/PRNG/RC4.pm
|
||||
lib/Crypt/PRNG/Sober128.pm
|
||||
lib/Crypt/PRNG/Yarrow.pm
|
||||
lib/Crypt/Stream/ChaCha.pm
|
||||
lib/Crypt/Stream/RC4.pm
|
||||
lib/Crypt/Stream/Sober128.pm
|
||||
lib/CryptX.pm
|
||||
lib/Math/BigInt/LTM.pm
|
||||
LICENSE
|
||||
Makefile.PL
|
||||
MANIFEST This list of files
|
||||
META.json
|
||||
META.yml
|
||||
ppport.h
|
||||
README
|
||||
src/ltc/ciphers/aes/aes.c
|
||||
src/ltc/ciphers/aes/aes_tab.c
|
||||
src/ltc/ciphers/anubis.c
|
||||
src/ltc/ciphers/blowfish.c
|
||||
src/ltc/ciphers/camellia.c
|
||||
src/ltc/ciphers/cast5.c
|
||||
src/ltc/ciphers/des.c
|
||||
src/ltc/ciphers/kasumi.c
|
||||
src/ltc/ciphers/khazad.c
|
||||
src/ltc/ciphers/kseed.c
|
||||
src/ltc/ciphers/multi2.c
|
||||
src/ltc/ciphers/noekeon.c
|
||||
src/ltc/ciphers/rc2.c
|
||||
src/ltc/ciphers/rc5.c
|
||||
src/ltc/ciphers/rc6.c
|
||||
src/ltc/ciphers/safer/safer.c
|
||||
src/ltc/ciphers/safer/safer_tab.c
|
||||
src/ltc/ciphers/safer/saferp.c
|
||||
src/ltc/ciphers/skipjack.c
|
||||
src/ltc/ciphers/twofish/twofish.c
|
||||
src/ltc/ciphers/twofish/twofish_tab.c
|
||||
src/ltc/ciphers/xtea.c
|
||||
src/ltc/encauth/ccm/ccm_add_aad.c
|
||||
src/ltc/encauth/ccm/ccm_add_nonce.c
|
||||
src/ltc/encauth/ccm/ccm_done.c
|
||||
src/ltc/encauth/ccm/ccm_init.c
|
||||
src/ltc/encauth/ccm/ccm_memory.c
|
||||
src/ltc/encauth/ccm/ccm_process.c
|
||||
src/ltc/encauth/ccm/ccm_reset.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_add_aad.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_decrypt.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_done.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_encrypt.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_init.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_memory.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_setiv.c
|
||||
src/ltc/encauth/chachapoly/chacha20poly1305_setiv_rfc7905.c
|
||||
src/ltc/encauth/eax/eax_addheader.c
|
||||
src/ltc/encauth/eax/eax_decrypt.c
|
||||
src/ltc/encauth/eax/eax_decrypt_verify_memory.c
|
||||
src/ltc/encauth/eax/eax_done.c
|
||||
src/ltc/encauth/eax/eax_encrypt.c
|
||||
src/ltc/encauth/eax/eax_encrypt_authenticate_memory.c
|
||||
src/ltc/encauth/eax/eax_init.c
|
||||
src/ltc/encauth/gcm/gcm_add_aad.c
|
||||
src/ltc/encauth/gcm/gcm_add_iv.c
|
||||
src/ltc/encauth/gcm/gcm_done.c
|
||||
src/ltc/encauth/gcm/gcm_gf_mult.c
|
||||
src/ltc/encauth/gcm/gcm_init.c
|
||||
src/ltc/encauth/gcm/gcm_memory.c
|
||||
src/ltc/encauth/gcm/gcm_mult_h.c
|
||||
src/ltc/encauth/gcm/gcm_process.c
|
||||
src/ltc/encauth/gcm/gcm_reset.c
|
||||
src/ltc/encauth/ocb3/ocb3_add_aad.c
|
||||
src/ltc/encauth/ocb3/ocb3_decrypt.c
|
||||
src/ltc/encauth/ocb3/ocb3_decrypt_last.c
|
||||
src/ltc/encauth/ocb3/ocb3_decrypt_verify_memory.c
|
||||
src/ltc/encauth/ocb3/ocb3_done.c
|
||||
src/ltc/encauth/ocb3/ocb3_encrypt.c
|
||||
src/ltc/encauth/ocb3/ocb3_encrypt_authenticate_memory.c
|
||||
src/ltc/encauth/ocb3/ocb3_encrypt_last.c
|
||||
src/ltc/encauth/ocb3/ocb3_init.c
|
||||
src/ltc/encauth/ocb3/ocb3_int_aad_add_block.c
|
||||
src/ltc/encauth/ocb3/ocb3_int_calc_offset_zero.c
|
||||
src/ltc/encauth/ocb3/ocb3_int_ntz.c
|
||||
src/ltc/encauth/ocb3/ocb3_int_xor_blocks.c
|
||||
src/ltc/hashes/blake2b.c
|
||||
src/ltc/hashes/blake2s.c
|
||||
src/ltc/hashes/chc/chc.c
|
||||
src/ltc/hashes/helper/hash_file.c
|
||||
src/ltc/hashes/helper/hash_filehandle.c
|
||||
src/ltc/hashes/helper/hash_memory.c
|
||||
src/ltc/hashes/helper/hash_memory_multi.c
|
||||
src/ltc/hashes/md2.c
|
||||
src/ltc/hashes/md4.c
|
||||
src/ltc/hashes/md5.c
|
||||
src/ltc/hashes/rmd128.c
|
||||
src/ltc/hashes/rmd160.c
|
||||
src/ltc/hashes/rmd256.c
|
||||
src/ltc/hashes/rmd320.c
|
||||
src/ltc/hashes/sha1.c
|
||||
src/ltc/hashes/sha2/sha224.c
|
||||
src/ltc/hashes/sha2/sha256.c
|
||||
src/ltc/hashes/sha2/sha384.c
|
||||
src/ltc/hashes/sha2/sha512.c
|
||||
src/ltc/hashes/sha2/sha512_224.c
|
||||
src/ltc/hashes/sha2/sha512_256.c
|
||||
src/ltc/hashes/sha3.c
|
||||
src/ltc/hashes/sha3_test.c
|
||||
src/ltc/hashes/tiger.c
|
||||
src/ltc/hashes/whirl/whirl.c
|
||||
src/ltc/hashes/whirl/whirltab.c
|
||||
src/ltc/headers/tomcrypt.h
|
||||
src/ltc/headers/tomcrypt_argchk.h
|
||||
src/ltc/headers/tomcrypt_cfg.h
|
||||
src/ltc/headers/tomcrypt_cipher.h
|
||||
src/ltc/headers/tomcrypt_custom.h
|
||||
src/ltc/headers/tomcrypt_hash.h
|
||||
src/ltc/headers/tomcrypt_mac.h
|
||||
src/ltc/headers/tomcrypt_macros.h
|
||||
src/ltc/headers/tomcrypt_math.h
|
||||
src/ltc/headers/tomcrypt_misc.h
|
||||
src/ltc/headers/tomcrypt_pk.h
|
||||
src/ltc/headers/tomcrypt_pkcs.h
|
||||
src/ltc/headers/tomcrypt_prng.h
|
||||
src/ltc/mac/blake2/blake2bmac.c
|
||||
src/ltc/mac/blake2/blake2bmac_file.c
|
||||
src/ltc/mac/blake2/blake2bmac_memory.c
|
||||
src/ltc/mac/blake2/blake2bmac_memory_multi.c
|
||||
src/ltc/mac/blake2/blake2smac.c
|
||||
src/ltc/mac/blake2/blake2smac_file.c
|
||||
src/ltc/mac/blake2/blake2smac_memory.c
|
||||
src/ltc/mac/blake2/blake2smac_memory_multi.c
|
||||
src/ltc/mac/f9/f9_done.c
|
||||
src/ltc/mac/f9/f9_file.c
|
||||
src/ltc/mac/f9/f9_init.c
|
||||
src/ltc/mac/f9/f9_memory.c
|
||||
src/ltc/mac/f9/f9_memory_multi.c
|
||||
src/ltc/mac/f9/f9_process.c
|
||||
src/ltc/mac/hmac/hmac_done.c
|
||||
src/ltc/mac/hmac/hmac_file.c
|
||||
src/ltc/mac/hmac/hmac_init.c
|
||||
src/ltc/mac/hmac/hmac_memory.c
|
||||
src/ltc/mac/hmac/hmac_memory_multi.c
|
||||
src/ltc/mac/hmac/hmac_process.c
|
||||
src/ltc/mac/omac/omac_done.c
|
||||
src/ltc/mac/omac/omac_file.c
|
||||
src/ltc/mac/omac/omac_init.c
|
||||
src/ltc/mac/omac/omac_memory.c
|
||||
src/ltc/mac/omac/omac_memory_multi.c
|
||||
src/ltc/mac/omac/omac_process.c
|
||||
src/ltc/mac/pelican/pelican.c
|
||||
src/ltc/mac/pelican/pelican_memory.c
|
||||
src/ltc/mac/pmac/pmac_done.c
|
||||
src/ltc/mac/pmac/pmac_file.c
|
||||
src/ltc/mac/pmac/pmac_init.c
|
||||
src/ltc/mac/pmac/pmac_memory.c
|
||||
src/ltc/mac/pmac/pmac_memory_multi.c
|
||||
src/ltc/mac/pmac/pmac_ntz.c
|
||||
src/ltc/mac/pmac/pmac_process.c
|
||||
src/ltc/mac/pmac/pmac_shift_xor.c
|
||||
src/ltc/mac/poly1305/poly1305.c
|
||||
src/ltc/mac/poly1305/poly1305_file.c
|
||||
src/ltc/mac/poly1305/poly1305_memory.c
|
||||
src/ltc/mac/poly1305/poly1305_memory_multi.c
|
||||
src/ltc/mac/xcbc/xcbc_done.c
|
||||
src/ltc/mac/xcbc/xcbc_file.c
|
||||
src/ltc/mac/xcbc/xcbc_init.c
|
||||
src/ltc/mac/xcbc/xcbc_memory.c
|
||||
src/ltc/mac/xcbc/xcbc_memory_multi.c
|
||||
src/ltc/mac/xcbc/xcbc_process.c
|
||||
src/ltc/math/fp/ltc_ecc_fp_mulmod.c
|
||||
src/ltc/math/ltm_desc.c
|
||||
src/ltc/math/multi.c
|
||||
src/ltc/math/rand_bn.c
|
||||
src/ltc/math/rand_prime.c
|
||||
src/ltc/math/tfm_desc.c
|
||||
src/ltc/misc/adler32.c
|
||||
src/ltc/misc/base64/base64_decode.c
|
||||
src/ltc/misc/base64/base64_encode.c
|
||||
src/ltc/misc/burn_stack.c
|
||||
src/ltc/misc/crc32.c
|
||||
src/ltc/misc/crypt/crypt.c
|
||||
src/ltc/misc/crypt/crypt_argchk.c
|
||||
src/ltc/misc/crypt/crypt_cipher_descriptor.c
|
||||
src/ltc/misc/crypt/crypt_cipher_is_valid.c
|
||||
src/ltc/misc/crypt/crypt_find_cipher.c
|
||||
src/ltc/misc/crypt/crypt_find_cipher_any.c
|
||||
src/ltc/misc/crypt/crypt_find_cipher_id.c
|
||||
src/ltc/misc/crypt/crypt_find_hash.c
|
||||
src/ltc/misc/crypt/crypt_find_hash_any.c
|
||||
src/ltc/misc/crypt/crypt_find_hash_id.c
|
||||
src/ltc/misc/crypt/crypt_find_hash_oid.c
|
||||
src/ltc/misc/crypt/crypt_find_prng.c
|
||||
src/ltc/misc/crypt/crypt_fsa.c
|
||||
src/ltc/misc/crypt/crypt_hash_descriptor.c
|
||||
src/ltc/misc/crypt/crypt_hash_is_valid.c
|
||||
src/ltc/misc/crypt/crypt_inits.c
|
||||
src/ltc/misc/crypt/crypt_ltc_mp_descriptor.c
|
||||
src/ltc/misc/crypt/crypt_prng_descriptor.c
|
||||
src/ltc/misc/crypt/crypt_prng_is_valid.c
|
||||
src/ltc/misc/crypt/crypt_register_cipher.c
|
||||
src/ltc/misc/crypt/crypt_register_hash.c
|
||||
src/ltc/misc/crypt/crypt_register_prng.c
|
||||
src/ltc/misc/crypt/crypt_unregister_cipher.c
|
||||
src/ltc/misc/crypt/crypt_unregister_hash.c
|
||||
src/ltc/misc/crypt/crypt_unregister_prng.c
|
||||
src/ltc/misc/error_to_string.c
|
||||
src/ltc/misc/hkdf/hkdf.c
|
||||
src/ltc/misc/mem_neq.c
|
||||
src/ltc/misc/pk_get_oid.c
|
||||
src/ltc/misc/pkcs5/pkcs_5_1.c
|
||||
src/ltc/misc/pkcs5/pkcs_5_2.c
|
||||
src/ltc/misc/zeromem.c
|
||||
src/ltc/modes/cbc/cbc_decrypt.c
|
||||
src/ltc/modes/cbc/cbc_done.c
|
||||
src/ltc/modes/cbc/cbc_encrypt.c
|
||||
src/ltc/modes/cbc/cbc_getiv.c
|
||||
src/ltc/modes/cbc/cbc_setiv.c
|
||||
src/ltc/modes/cbc/cbc_start.c
|
||||
src/ltc/modes/cfb/cfb_decrypt.c
|
||||
src/ltc/modes/cfb/cfb_done.c
|
||||
src/ltc/modes/cfb/cfb_encrypt.c
|
||||
src/ltc/modes/cfb/cfb_getiv.c
|
||||
src/ltc/modes/cfb/cfb_setiv.c
|
||||
src/ltc/modes/cfb/cfb_start.c
|
||||
src/ltc/modes/ctr/ctr_decrypt.c
|
||||
src/ltc/modes/ctr/ctr_done.c
|
||||
src/ltc/modes/ctr/ctr_encrypt.c
|
||||
src/ltc/modes/ctr/ctr_getiv.c
|
||||
src/ltc/modes/ctr/ctr_setiv.c
|
||||
src/ltc/modes/ctr/ctr_start.c
|
||||
src/ltc/modes/ecb/ecb_decrypt.c
|
||||
src/ltc/modes/ecb/ecb_done.c
|
||||
src/ltc/modes/ecb/ecb_encrypt.c
|
||||
src/ltc/modes/ecb/ecb_start.c
|
||||
src/ltc/modes/ofb/ofb_decrypt.c
|
||||
src/ltc/modes/ofb/ofb_done.c
|
||||
src/ltc/modes/ofb/ofb_encrypt.c
|
||||
src/ltc/modes/ofb/ofb_getiv.c
|
||||
src/ltc/modes/ofb/ofb_setiv.c
|
||||
src/ltc/modes/ofb/ofb_start.c
|
||||
src/ltc/pk/asn1/der/bit/der_decode_bit_string.c
|
||||
src/ltc/pk/asn1/der/bit/der_decode_raw_bit_string.c
|
||||
src/ltc/pk/asn1/der/bit/der_encode_bit_string.c
|
||||
src/ltc/pk/asn1/der/bit/der_encode_raw_bit_string.c
|
||||
src/ltc/pk/asn1/der/bit/der_length_bit_string.c
|
||||
src/ltc/pk/asn1/der/boolean/der_decode_boolean.c
|
||||
src/ltc/pk/asn1/der/boolean/der_encode_boolean.c
|
||||
src/ltc/pk/asn1/der/boolean/der_length_boolean.c
|
||||
src/ltc/pk/asn1/der/choice/der_decode_choice.c
|
||||
src/ltc/pk/asn1/der/generalizedtime/der_decode_generalizedtime.c
|
||||
src/ltc/pk/asn1/der/generalizedtime/der_encode_generalizedtime.c
|
||||
src/ltc/pk/asn1/der/generalizedtime/der_length_generalizedtime.c
|
||||
src/ltc/pk/asn1/der/ia5/der_decode_ia5_string.c
|
||||
src/ltc/pk/asn1/der/ia5/der_encode_ia5_string.c
|
||||
src/ltc/pk/asn1/der/ia5/der_length_ia5_string.c
|
||||
src/ltc/pk/asn1/der/integer/der_decode_integer.c
|
||||
src/ltc/pk/asn1/der/integer/der_encode_integer.c
|
||||
src/ltc/pk/asn1/der/integer/der_length_integer.c
|
||||
src/ltc/pk/asn1/der/object_identifier/der_decode_object_identifier.c
|
||||
src/ltc/pk/asn1/der/object_identifier/der_encode_object_identifier.c
|
||||
src/ltc/pk/asn1/der/object_identifier/der_length_object_identifier.c
|
||||
src/ltc/pk/asn1/der/octet/der_decode_octet_string.c
|
||||
src/ltc/pk/asn1/der/octet/der_encode_octet_string.c
|
||||
src/ltc/pk/asn1/der/octet/der_length_octet_string.c
|
||||
src/ltc/pk/asn1/der/printable_string/der_decode_printable_string.c
|
||||
src/ltc/pk/asn1/der/printable_string/der_encode_printable_string.c
|
||||
src/ltc/pk/asn1/der/printable_string/der_length_printable_string.c
|
||||
src/ltc/pk/asn1/der/sequence/der_decode_sequence_ex.c
|
||||
src/ltc/pk/asn1/der/sequence/der_decode_sequence_flexi.c
|
||||
src/ltc/pk/asn1/der/sequence/der_decode_sequence_multi.c
|
||||
src/ltc/pk/asn1/der/sequence/der_decode_subject_public_key_info.c
|
||||
src/ltc/pk/asn1/der/sequence/der_encode_sequence_ex.c
|
||||
src/ltc/pk/asn1/der/sequence/der_encode_sequence_multi.c
|
||||
src/ltc/pk/asn1/der/sequence/der_encode_subject_public_key_info.c
|
||||
src/ltc/pk/asn1/der/sequence/der_length_sequence.c
|
||||
src/ltc/pk/asn1/der/sequence/der_sequence_free.c
|
||||
src/ltc/pk/asn1/der/set/der_encode_set.c
|
||||
src/ltc/pk/asn1/der/set/der_encode_setof.c
|
||||
src/ltc/pk/asn1/der/short_integer/der_decode_short_integer.c
|
||||
src/ltc/pk/asn1/der/short_integer/der_encode_short_integer.c
|
||||
src/ltc/pk/asn1/der/short_integer/der_length_short_integer.c
|
||||
src/ltc/pk/asn1/der/teletex_string/der_decode_teletex_string.c
|
||||
src/ltc/pk/asn1/der/teletex_string/der_length_teletex_string.c
|
||||
src/ltc/pk/asn1/der/utctime/der_decode_utctime.c
|
||||
src/ltc/pk/asn1/der/utctime/der_encode_utctime.c
|
||||
src/ltc/pk/asn1/der/utctime/der_length_utctime.c
|
||||
src/ltc/pk/asn1/der/utf8/der_decode_utf8_string.c
|
||||
src/ltc/pk/asn1/der/utf8/der_encode_utf8_string.c
|
||||
src/ltc/pk/asn1/der/utf8/der_length_utf8_string.c
|
||||
src/ltc/pk/dh/dh.c
|
||||
src/ltc/pk/dh/dh_static.c
|
||||
src/ltc/pk/dh/dh_static.h
|
||||
src/ltc/pk/dh/dh_sys.c
|
||||
src/ltc/pk/dsa/dsa_decrypt_key.c
|
||||
src/ltc/pk/dsa/dsa_encrypt_key.c
|
||||
src/ltc/pk/dsa/dsa_export.c
|
||||
src/ltc/pk/dsa/dsa_free.c
|
||||
src/ltc/pk/dsa/dsa_import.c
|
||||
src/ltc/pk/dsa/dsa_import_radix.c
|
||||
src/ltc/pk/dsa/dsa_make_key.c
|
||||
src/ltc/pk/dsa/dsa_shared_secret.c
|
||||
src/ltc/pk/dsa/dsa_sign_hash.c
|
||||
src/ltc/pk/dsa/dsa_verify_hash.c
|
||||
src/ltc/pk/dsa/dsa_verify_key.c
|
||||
src/ltc/pk/ecc/ecc.c
|
||||
src/ltc/pk/ecc/ecc_ansi_x963_export.c
|
||||
src/ltc/pk/ecc/ecc_ansi_x963_import.c
|
||||
src/ltc/pk/ecc/ecc_decrypt_key.c
|
||||
src/ltc/pk/ecc/ecc_dp_clear.c
|
||||
src/ltc/pk/ecc/ecc_dp_fill_from_sets.c
|
||||
src/ltc/pk/ecc/ecc_dp_from_oid.c
|
||||
src/ltc/pk/ecc/ecc_dp_from_params.c
|
||||
src/ltc/pk/ecc/ecc_dp_init.c
|
||||
src/ltc/pk/ecc/ecc_dp_set.c
|
||||
src/ltc/pk/ecc/ecc_encrypt_key.c
|
||||
src/ltc/pk/ecc/ecc_export.c
|
||||
src/ltc/pk/ecc/ecc_export_full.c
|
||||
src/ltc/pk/ecc/ecc_export_raw.c
|
||||
src/ltc/pk/ecc/ecc_free.c
|
||||
src/ltc/pk/ecc/ecc_get_size.c
|
||||
src/ltc/pk/ecc/ecc_import.c
|
||||
src/ltc/pk/ecc/ecc_import_full.c
|
||||
src/ltc/pk/ecc/ecc_import_pkcs8.c
|
||||
src/ltc/pk/ecc/ecc_import_raw.c
|
||||
src/ltc/pk/ecc/ecc_make_key.c
|
||||
src/ltc/pk/ecc/ecc_shared_secret.c
|
||||
src/ltc/pk/ecc/ecc_sign_hash.c
|
||||
src/ltc/pk/ecc/ecc_sizes.c
|
||||
src/ltc/pk/ecc/ecc_verify_hash.c
|
||||
src/ltc/pk/ecc/ecc_verify_key.c
|
||||
src/ltc/pk/ecc/ltc_ecc_export_point.c
|
||||
src/ltc/pk/ecc/ltc_ecc_import_point.c
|
||||
src/ltc/pk/ecc/ltc_ecc_is_point.c
|
||||
src/ltc/pk/ecc/ltc_ecc_is_point_at_infinity.c
|
||||
src/ltc/pk/ecc/ltc_ecc_is_valid_idx.c
|
||||
src/ltc/pk/ecc/ltc_ecc_map.c
|
||||
src/ltc/pk/ecc/ltc_ecc_mul2add.c
|
||||
src/ltc/pk/ecc/ltc_ecc_mulmod.c
|
||||
src/ltc/pk/ecc/ltc_ecc_mulmod_timing.c
|
||||
src/ltc/pk/ecc/ltc_ecc_points.c
|
||||
src/ltc/pk/ecc/ltc_ecc_projective_add_point.c
|
||||
src/ltc/pk/ecc/ltc_ecc_projective_dbl_point.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_i2osp.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_mgf1.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_oaep_decode.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_oaep_encode.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_os2ip.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_pss_decode.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_pss_encode.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_v1_5_decode.c
|
||||
src/ltc/pk/pkcs1/pkcs_1_v1_5_encode.c
|
||||
src/ltc/pk/rsa/rsa_decrypt_key.c
|
||||
src/ltc/pk/rsa/rsa_encrypt_key.c
|
||||
src/ltc/pk/rsa/rsa_export.c
|
||||
src/ltc/pk/rsa/rsa_exptmod.c
|
||||
src/ltc/pk/rsa/rsa_free.c
|
||||
src/ltc/pk/rsa/rsa_get_size.c
|
||||
src/ltc/pk/rsa/rsa_import.c
|
||||
src/ltc/pk/rsa/rsa_import_pkcs8.c
|
||||
src/ltc/pk/rsa/rsa_import_radix.c
|
||||
src/ltc/pk/rsa/rsa_import_x509.c
|
||||
src/ltc/pk/rsa/rsa_make_key.c
|
||||
src/ltc/pk/rsa/rsa_sign_hash.c
|
||||
src/ltc/pk/rsa/rsa_sign_saltlen_get.c
|
||||
src/ltc/pk/rsa/rsa_verify_hash.c
|
||||
src/ltc/prngs/chacha20.c
|
||||
src/ltc/prngs/fortuna.c
|
||||
src/ltc/prngs/rc4.c
|
||||
src/ltc/prngs/rng_get_bytes.c
|
||||
src/ltc/prngs/rng_make_prng.c
|
||||
src/ltc/prngs/sober128.c
|
||||
src/ltc/prngs/sprng.c
|
||||
src/ltc/prngs/yarrow.c
|
||||
src/ltc/stream/chacha/chacha_crypt.c
|
||||
src/ltc/stream/chacha/chacha_done.c
|
||||
src/ltc/stream/chacha/chacha_ivctr32.c
|
||||
src/ltc/stream/chacha/chacha_ivctr64.c
|
||||
src/ltc/stream/chacha/chacha_keystream.c
|
||||
src/ltc/stream/chacha/chacha_setup.c
|
||||
src/ltc/stream/rc4/rc4.c
|
||||
src/ltc/stream/sober128/sober128.c
|
||||
src/ltc/stream/sober128/sober128tab.c
|
||||
src/ltm/bn_error.c
|
||||
src/ltm/bn_fast_mp_invmod.c
|
||||
src/ltm/bn_fast_mp_montgomery_reduce.c
|
||||
src/ltm/bn_fast_s_mp_mul_digs.c
|
||||
src/ltm/bn_fast_s_mp_mul_high_digs.c
|
||||
src/ltm/bn_fast_s_mp_sqr.c
|
||||
src/ltm/bn_mp_2expt.c
|
||||
src/ltm/bn_mp_abs.c
|
||||
src/ltm/bn_mp_add.c
|
||||
src/ltm/bn_mp_add_d.c
|
||||
src/ltm/bn_mp_addmod.c
|
||||
src/ltm/bn_mp_and.c
|
||||
src/ltm/bn_mp_clamp.c
|
||||
src/ltm/bn_mp_clear.c
|
||||
src/ltm/bn_mp_clear_multi.c
|
||||
src/ltm/bn_mp_cmp.c
|
||||
src/ltm/bn_mp_cmp_d.c
|
||||
src/ltm/bn_mp_cmp_mag.c
|
||||
src/ltm/bn_mp_cnt_lsb.c
|
||||
src/ltm/bn_mp_copy.c
|
||||
src/ltm/bn_mp_count_bits.c
|
||||
src/ltm/bn_mp_div.c
|
||||
src/ltm/bn_mp_div_2.c
|
||||
src/ltm/bn_mp_div_2d.c
|
||||
src/ltm/bn_mp_div_3.c
|
||||
src/ltm/bn_mp_div_d.c
|
||||
src/ltm/bn_mp_dr_is_modulus.c
|
||||
src/ltm/bn_mp_dr_reduce.c
|
||||
src/ltm/bn_mp_dr_setup.c
|
||||
src/ltm/bn_mp_exch.c
|
||||
src/ltm/bn_mp_export.c
|
||||
src/ltm/bn_mp_expt_d.c
|
||||
src/ltm/bn_mp_expt_d_ex.c
|
||||
src/ltm/bn_mp_exptmod.c
|
||||
src/ltm/bn_mp_exptmod_fast.c
|
||||
src/ltm/bn_mp_exteuclid.c
|
||||
src/ltm/bn_mp_fread.c
|
||||
src/ltm/bn_mp_fwrite.c
|
||||
src/ltm/bn_mp_gcd.c
|
||||
src/ltm/bn_mp_get_int.c
|
||||
src/ltm/bn_mp_get_long.c
|
||||
src/ltm/bn_mp_get_long_long.c
|
||||
src/ltm/bn_mp_grow.c
|
||||
src/ltm/bn_mp_import.c
|
||||
src/ltm/bn_mp_init.c
|
||||
src/ltm/bn_mp_init_copy.c
|
||||
src/ltm/bn_mp_init_multi.c
|
||||
src/ltm/bn_mp_init_set.c
|
||||
src/ltm/bn_mp_init_set_int.c
|
||||
src/ltm/bn_mp_init_size.c
|
||||
src/ltm/bn_mp_invmod.c
|
||||
src/ltm/bn_mp_invmod_slow.c
|
||||
src/ltm/bn_mp_is_square.c
|
||||
src/ltm/bn_mp_jacobi.c
|
||||
src/ltm/bn_mp_karatsuba_mul.c
|
||||
src/ltm/bn_mp_karatsuba_sqr.c
|
||||
src/ltm/bn_mp_lcm.c
|
||||
src/ltm/bn_mp_lshd.c
|
||||
src/ltm/bn_mp_mod.c
|
||||
src/ltm/bn_mp_mod_2d.c
|
||||
src/ltm/bn_mp_mod_d.c
|
||||
src/ltm/bn_mp_montgomery_calc_normalization.c
|
||||
src/ltm/bn_mp_montgomery_reduce.c
|
||||
src/ltm/bn_mp_montgomery_setup.c
|
||||
src/ltm/bn_mp_mul.c
|
||||
src/ltm/bn_mp_mul_2.c
|
||||
src/ltm/bn_mp_mul_2d.c
|
||||
src/ltm/bn_mp_mul_d.c
|
||||
src/ltm/bn_mp_mulmod.c
|
||||
src/ltm/bn_mp_n_root.c
|
||||
src/ltm/bn_mp_n_root_ex.c
|
||||
src/ltm/bn_mp_neg.c
|
||||
src/ltm/bn_mp_or.c
|
||||
src/ltm/bn_mp_prime_fermat.c
|
||||
src/ltm/bn_mp_prime_is_divisible.c
|
||||
src/ltm/bn_mp_prime_is_prime.c
|
||||
src/ltm/bn_mp_prime_miller_rabin.c
|
||||
src/ltm/bn_mp_prime_next_prime.c
|
||||
src/ltm/bn_mp_prime_rabin_miller_trials.c
|
||||
src/ltm/bn_mp_prime_random_ex.c
|
||||
src/ltm/bn_mp_radix_size.c
|
||||
src/ltm/bn_mp_radix_smap.c
|
||||
src/ltm/bn_mp_rand.c
|
||||
src/ltm/bn_mp_read_radix.c
|
||||
src/ltm/bn_mp_read_signed_bin.c
|
||||
src/ltm/bn_mp_read_unsigned_bin.c
|
||||
src/ltm/bn_mp_reduce.c
|
||||
src/ltm/bn_mp_reduce_2k.c
|
||||
src/ltm/bn_mp_reduce_2k_l.c
|
||||
src/ltm/bn_mp_reduce_2k_setup.c
|
||||
src/ltm/bn_mp_reduce_2k_setup_l.c
|
||||
src/ltm/bn_mp_reduce_is_2k.c
|
||||
src/ltm/bn_mp_reduce_is_2k_l.c
|
||||
src/ltm/bn_mp_reduce_setup.c
|
||||
src/ltm/bn_mp_rshd.c
|
||||
src/ltm/bn_mp_set.c
|
||||
src/ltm/bn_mp_set_int.c
|
||||
src/ltm/bn_mp_set_long.c
|
||||
src/ltm/bn_mp_set_long_long.c
|
||||
src/ltm/bn_mp_shrink.c
|
||||
src/ltm/bn_mp_signed_bin_size.c
|
||||
src/ltm/bn_mp_sqr.c
|
||||
src/ltm/bn_mp_sqrmod.c
|
||||
src/ltm/bn_mp_sqrt.c
|
||||
src/ltm/bn_mp_sqrtmod_prime.c
|
||||
src/ltm/bn_mp_sub.c
|
||||
src/ltm/bn_mp_sub_d.c
|
||||
src/ltm/bn_mp_submod.c
|
||||
src/ltm/bn_mp_to_signed_bin.c
|
||||
src/ltm/bn_mp_to_signed_bin_n.c
|
||||
src/ltm/bn_mp_to_unsigned_bin.c
|
||||
src/ltm/bn_mp_to_unsigned_bin_n.c
|
||||
src/ltm/bn_mp_toom_mul.c
|
||||
src/ltm/bn_mp_toom_sqr.c
|
||||
src/ltm/bn_mp_toradix.c
|
||||
src/ltm/bn_mp_toradix_n.c
|
||||
src/ltm/bn_mp_unsigned_bin_size.c
|
||||
src/ltm/bn_mp_xor.c
|
||||
src/ltm/bn_mp_zero.c
|
||||
src/ltm/bn_prime_tab.c
|
||||
src/ltm/bn_reverse.c
|
||||
src/ltm/bn_s_mp_add.c
|
||||
src/ltm/bn_s_mp_exptmod.c
|
||||
src/ltm/bn_s_mp_mul_digs.c
|
||||
src/ltm/bn_s_mp_mul_high_digs.c
|
||||
src/ltm/bn_s_mp_sqr.c
|
||||
src/ltm/bn_s_mp_sub.c
|
||||
src/ltm/bncore.c
|
||||
src/ltm/tommath.h
|
||||
src/ltm/tommath_class.h
|
||||
src/ltm/tommath_private.h
|
||||
src/ltm/tommath_superclass.h
|
||||
src/Makefile
|
||||
src/Makefile.nmake
|
||||
t/001_compile.t
|
||||
t/002_all_pm.t
|
||||
t/003_all_pm_pod.t
|
||||
t/auth_enc_ccm.t
|
||||
t/auth_enc_ccm_test_vector_ltc.t
|
||||
t/auth_enc_chacha20poly1305.t
|
||||
t/auth_enc_eax.t
|
||||
t/auth_enc_eax_test_vector_ltc.t
|
||||
t/auth_enc_gcm.t
|
||||
t/auth_enc_gcm_test_vector_ltc.t
|
||||
t/auth_enc_ocb.t
|
||||
t/auth_enc_ocb_test_vectors_ietf.t
|
||||
t/checksum.t
|
||||
t/cipher_aes.t
|
||||
t/cipher_aes_test_vectors_bc.t
|
||||
t/cipher_anubis.t
|
||||
t/cipher_blowfish.t
|
||||
t/cipher_camellia.t
|
||||
t/cipher_cast5.t
|
||||
t/cipher_des.t
|
||||
t/cipher_des_ede.t
|
||||
t/cipher_kasumi.t
|
||||
t/cipher_khazad.t
|
||||
t/cipher_multi2.t
|
||||
t/cipher_multi2_rounds.t
|
||||
t/cipher_noekeon.t
|
||||
t/cipher_rc2.t
|
||||
t/cipher_rc5.t
|
||||
t/cipher_rc6.t
|
||||
t/cipher_safer_k128.t
|
||||
t/cipher_safer_k64.t
|
||||
t/cipher_safer_sk128.t
|
||||
t/cipher_safer_sk64.t
|
||||
t/cipher_saferp.t
|
||||
t/cipher_seed.t
|
||||
t/cipher_seed_test_vectors_bc.t
|
||||
t/cipher_skipjack.t
|
||||
t/cipher_stream.t
|
||||
t/cipher_test_vectors_ltc.t
|
||||
t/cipher_test_vectors_openssl.t
|
||||
t/cipher_twofish.t
|
||||
t/cipher_twofish_test_vectors_bc.t
|
||||
t/cipher_xtea.t
|
||||
t/cipher_xtea_test_vectors_bc.t
|
||||
t/crypt-misc.t
|
||||
t/data/binary-test.file
|
||||
t/data/cryptx_priv_dh1.bin
|
||||
t/data/cryptx_priv_dh2.bin
|
||||
t/data/cryptx_priv_dh_pg1.bin
|
||||
t/data/cryptx_priv_dh_pg2.bin
|
||||
t/data/cryptx_priv_dsa1.der
|
||||
t/data/cryptx_priv_dsa1.pem
|
||||
t/data/cryptx_priv_dsa2.der
|
||||
t/data/cryptx_priv_dsa2.pem
|
||||
t/data/cryptx_priv_ecc1.der
|
||||
t/data/cryptx_priv_ecc1.pem
|
||||
t/data/cryptx_priv_ecc1_OLD.der
|
||||
t/data/cryptx_priv_ecc1_OLD.pem
|
||||
t/data/cryptx_priv_ecc2.der
|
||||
t/data/cryptx_priv_ecc2.pem
|
||||
t/data/cryptx_priv_ecc2_OLD.der
|
||||
t/data/cryptx_priv_ecc2_OLD.pem
|
||||
t/data/cryptx_priv_rsa1.der
|
||||
t/data/cryptx_priv_rsa1.pem
|
||||
t/data/cryptx_priv_rsa2.der
|
||||
t/data/cryptx_priv_rsa2.pem
|
||||
t/data/cryptx_pub_dh1.bin
|
||||
t/data/cryptx_pub_dh2.bin
|
||||
t/data/cryptx_pub_dh_pg1.bin
|
||||
t/data/cryptx_pub_dh_pg2.bin
|
||||
t/data/cryptx_pub_dsa1.der
|
||||
t/data/cryptx_pub_dsa1.pem
|
||||
t/data/cryptx_pub_dsa2.der
|
||||
t/data/cryptx_pub_dsa2.pem
|
||||
t/data/cryptx_pub_ecc1.der
|
||||
t/data/cryptx_pub_ecc1.pem
|
||||
t/data/cryptx_pub_ecc1_OLD.der
|
||||
t/data/cryptx_pub_ecc1_OLD.pem
|
||||
t/data/cryptx_pub_ecc2.der
|
||||
t/data/cryptx_pub_ecc2.pem
|
||||
t/data/cryptx_pub_ecc2_OLD.der
|
||||
t/data/cryptx_pub_ecc2_OLD.pem
|
||||
t/data/cryptx_pub_rsa1.der
|
||||
t/data/cryptx_pub_rsa1.pem
|
||||
t/data/cryptx_pub_rsa2.der
|
||||
t/data/cryptx_pub_rsa2.pem
|
||||
t/data/dsa-aes128.pem
|
||||
t/data/dsa-aes192.pem
|
||||
t/data/dsa-aes256.pem
|
||||
t/data/dsa-camellia128.pem
|
||||
t/data/dsa-camellia192.pem
|
||||
t/data/dsa-camellia256.pem
|
||||
t/data/dsa-des.pem
|
||||
t/data/dsa-des3.pem
|
||||
t/data/dsa-param.pem
|
||||
t/data/dsa-seed.pem
|
||||
t/data/ec-aes128.pem
|
||||
t/data/ec-aes192.pem
|
||||
t/data/ec-aes256.pem
|
||||
t/data/ec-camellia128.pem
|
||||
t/data/ec-camellia192.pem
|
||||
t/data/ec-camellia256.pem
|
||||
t/data/ec-des.pem
|
||||
t/data/ec-des3.pem
|
||||
t/data/ec-seed.pem
|
||||
t/data/jwk_ec-priv1.json
|
||||
t/data/jwk_ec-pub.json
|
||||
t/data/jwk_ec-pub1.json
|
||||
t/data/jwk_rsa-priv.json
|
||||
t/data/jwk_rsa-priv1.json
|
||||
t/data/jwk_rsa-pub1.json
|
||||
t/data/openssl_dsa1.der
|
||||
t/data/openssl_dsa1.pem
|
||||
t/data/openssl_dsa2.der
|
||||
t/data/openssl_dsa2.pem
|
||||
t/data/openssl_ec-short.der
|
||||
t/data/openssl_ec-short.pem
|
||||
t/data/openssl_ec-short.pub.der
|
||||
t/data/openssl_ec-short.pub.pem
|
||||
t/data/openssl_ec1.key.pem
|
||||
t/data/openssl_ec1.pri.der
|
||||
t/data/openssl_ec1.pri.pem
|
||||
t/data/openssl_ec1.pric.der
|
||||
t/data/openssl_ec1.pric.pem
|
||||
t/data/openssl_ec1.pub.der
|
||||
t/data/openssl_ec1.pub.pem
|
||||
t/data/openssl_ec1.pubc.der
|
||||
t/data/openssl_ec1.pubc.pem
|
||||
t/data/openssl_rsa1.der
|
||||
t/data/openssl_rsa1.pem
|
||||
t/data/openssl_rsa1.pubonly.der
|
||||
t/data/openssl_rsa1.pubonly.pem
|
||||
t/data/openssl_rsa2.der
|
||||
t/data/openssl_rsa2.pem
|
||||
t/data/openssl_rsa2.pubonly.der
|
||||
t/data/openssl_rsa2.pubonly.pem
|
||||
t/data/pkcs8.ec-priv-nopass.der
|
||||
t/data/pkcs8.ec-priv-nopass.pem
|
||||
t/data/pkcs8.ec-priv-pass.der
|
||||
t/data/pkcs8.ec-priv-pass.pem
|
||||
t/data/pkcs8.ec-short-priv-nopass.der
|
||||
t/data/pkcs8.ec-short-priv-nopass.pem
|
||||
t/data/pkcs8.ec-short-priv-pass.der
|
||||
t/data/pkcs8.ec-short-priv-pass.pem
|
||||
t/data/pkcs8.rsa-priv-nopass.der
|
||||
t/data/pkcs8.rsa-priv-nopass.pem
|
||||
t/data/pkcs8.rsa-priv-pass.der
|
||||
t/data/pkcs8.rsa-priv-pass.pem
|
||||
t/data/rsa-aes128.pem
|
||||
t/data/rsa-aes192.pem
|
||||
t/data/rsa-aes256.pem
|
||||
t/data/rsa-camellia128.pem
|
||||
t/data/rsa-camellia192.pem
|
||||
t/data/rsa-camellia256.pem
|
||||
t/data/rsa-des.pem
|
||||
t/data/rsa-des3.pem
|
||||
t/data/rsa-seed.pem
|
||||
t/data/ssh/ssh_dsa_1024
|
||||
t/data/ssh/ssh_dsa_1024.pub
|
||||
t/data/ssh/ssh_dsa_1024.pub.pkcs8
|
||||
t/data/ssh/ssh_dsa_1024.pub.rfc4716
|
||||
t/data/ssh/ssh_ecdsa_256
|
||||
t/data/ssh/ssh_ecdsa_256.pub
|
||||
t/data/ssh/ssh_ecdsa_256.pub.pkcs8
|
||||
t/data/ssh/ssh_ecdsa_256.pub.rfc4716
|
||||
t/data/ssh/ssh_ecdsa_384
|
||||
t/data/ssh/ssh_ecdsa_384.pub
|
||||
t/data/ssh/ssh_ecdsa_384.pub.pkcs8
|
||||
t/data/ssh/ssh_ecdsa_384.pub.rfc4716
|
||||
t/data/ssh/ssh_ecdsa_521
|
||||
t/data/ssh/ssh_ecdsa_521.pub
|
||||
t/data/ssh/ssh_ecdsa_521.pub.pkcs8
|
||||
t/data/ssh/ssh_ecdsa_521.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_1024
|
||||
t/data/ssh/ssh_rsa_1024.pub
|
||||
t/data/ssh/ssh_rsa_1024.pub.pem
|
||||
t/data/ssh/ssh_rsa_1024.pub.pkcs8
|
||||
t/data/ssh/ssh_rsa_1024.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_1024_passwd
|
||||
t/data/ssh/ssh_rsa_1536
|
||||
t/data/ssh/ssh_rsa_1536.pub
|
||||
t/data/ssh/ssh_rsa_1536.pub.pem
|
||||
t/data/ssh/ssh_rsa_1536.pub.pkcs8
|
||||
t/data/ssh/ssh_rsa_1536.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_1536_passwd
|
||||
t/data/ssh/ssh_rsa_2048
|
||||
t/data/ssh/ssh_rsa_2048.pub
|
||||
t/data/ssh/ssh_rsa_2048.pub.pem
|
||||
t/data/ssh/ssh_rsa_2048.pub.pkcs8
|
||||
t/data/ssh/ssh_rsa_2048.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_2048_passwd
|
||||
t/data/ssh/ssh_rsa_4096
|
||||
t/data/ssh/ssh_rsa_4096.pub
|
||||
t/data/ssh/ssh_rsa_4096.pub.pem
|
||||
t/data/ssh/ssh_rsa_4096.pub.pkcs8
|
||||
t/data/ssh/ssh_rsa_4096.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_4096_passwd
|
||||
t/data/ssh/ssh_rsa_768
|
||||
t/data/ssh/ssh_rsa_768.pub
|
||||
t/data/ssh/ssh_rsa_768.pub.pem
|
||||
t/data/ssh/ssh_rsa_768.pub.pkcs8
|
||||
t/data/ssh/ssh_rsa_768.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_768_passwd
|
||||
t/data/ssh/ssh_rsa_8192
|
||||
t/data/ssh/ssh_rsa_8192.pub
|
||||
t/data/ssh/ssh_rsa_8192.pub.pem
|
||||
t/data/ssh/ssh_rsa_8192.pub.pkcs8
|
||||
t/data/ssh/ssh_rsa_8192.pub.rfc4716
|
||||
t/data/ssh/ssh_rsa_8192_passwd
|
||||
t/data/text-CR.file
|
||||
t/data/text-CRLF.file
|
||||
t/data/text-LF.file
|
||||
t/digest_blake2b_160.t
|
||||
t/digest_blake2b_256.t
|
||||
t/digest_blake2b_384.t
|
||||
t/digest_blake2b_512.t
|
||||
t/digest_blake2s_128.t
|
||||
t/digest_blake2s_160.t
|
||||
t/digest_blake2s_224.t
|
||||
t/digest_blake2s_256.t
|
||||
t/digest_chaes.t
|
||||
t/digest_md2.t
|
||||
t/digest_md4.t
|
||||
t/digest_md5.t
|
||||
t/digest_ripemd128.t
|
||||
t/digest_ripemd160.t
|
||||
t/digest_ripemd256.t
|
||||
t/digest_ripemd320.t
|
||||
t/digest_sha1.t
|
||||
t/digest_sha224.t
|
||||
t/digest_sha256.t
|
||||
t/digest_sha384.t
|
||||
t/digest_sha3_224.t
|
||||
t/digest_sha3_256.t
|
||||
t/digest_sha3_384.t
|
||||
t/digest_sha3_512.t
|
||||
t/digest_sha512.t
|
||||
t/digest_sha512_224.t
|
||||
t/digest_sha512_256.t
|
||||
t/digest_shake.t
|
||||
t/digest_test_vectors_ltc.t
|
||||
t/digest_tiger192.t
|
||||
t/digest_whirlpool.t
|
||||
t/jwk.t
|
||||
t/key_derivation.t
|
||||
t/mac_blake2b.t
|
||||
t/mac_blake2s.t
|
||||
t/mac_f9.t
|
||||
t/mac_hmac.t
|
||||
t/mac_hmac_test_vectors_ltc.t
|
||||
t/mac_omac.t
|
||||
t/mac_omac_test_vectors_ltc.t
|
||||
t/mac_pelican.t
|
||||
t/mac_pmac.t
|
||||
t/mac_pmac_test_vectors_ltc.t
|
||||
t/mac_poly1305.t
|
||||
t/mac_xcbc.t
|
||||
t/mbi_ltm/bigfltpm.inc
|
||||
t/mbi_ltm/bigintpm.inc
|
||||
t/mbi_ltm_01load.t
|
||||
t/mbi_ltm_bigfltpm.t
|
||||
t/mbi_ltm_bigintg.t
|
||||
t/mbi_ltm_bigintpm.t
|
||||
t/mbi_ltm_biglog.t
|
||||
t/mbi_ltm_bigroot.t
|
||||
t/mbi_ltm_bugs.t
|
||||
t/mbi_ltm_mbi-from-big-scalar.t
|
||||
t/mbi_ltm_storable.t
|
||||
t/mode_cbc.t
|
||||
t/mode_cfb.t
|
||||
t/mode_ctr.t
|
||||
t/mode_ecb.t
|
||||
t/mode_ofb.t
|
||||
t/pk_dh.t
|
||||
t/pk_dsa.t
|
||||
t/pk_dsa_test_vectors_openssl.t
|
||||
t/pk_ecc.t
|
||||
t/pk_ecc_test_vectors_openssl.t
|
||||
t/pk_enc_pem.t
|
||||
t/pk_rsa.t
|
||||
t/pk_rsa_test_vectors_openssl.t
|
||||
t/pkcs8.t
|
||||
t/prng.t
|
||||
t/prng_chacha20.t
|
||||
t/prng_fortuna.t
|
||||
t/prng_rc4.t
|
||||
t/prng_sober128.t
|
||||
t/prng_yarrow.t
|
||||
t/sshkey.t
|
||||
typemap
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
{
|
||||
"abstract" : "Crypto toolkit",
|
||||
"author" : [
|
||||
"Karel Miko"
|
||||
],
|
||||
"dynamic_config" : 1,
|
||||
"generated_by" : "ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010",
|
||||
"license" : [
|
||||
"perl_5"
|
||||
],
|
||||
"meta-spec" : {
|
||||
"url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
|
||||
"version" : "2"
|
||||
},
|
||||
"name" : "CryptX",
|
||||
"no_index" : {
|
||||
"directory" : [
|
||||
"t",
|
||||
"inc"
|
||||
]
|
||||
},
|
||||
"prereqs" : {
|
||||
"build" : {
|
||||
"requires" : {
|
||||
"ExtUtils::MakeMaker" : "0"
|
||||
}
|
||||
},
|
||||
"configure" : {
|
||||
"requires" : {
|
||||
"ExtUtils::MakeMaker" : "0"
|
||||
}
|
||||
},
|
||||
"runtime" : {
|
||||
"requires" : {
|
||||
"perl" : "5.006"
|
||||
}
|
||||
}
|
||||
},
|
||||
"release_status" : "stable",
|
||||
"resources" : {
|
||||
"bugtracker" : {
|
||||
"web" : "https://github.com/DCIT/perl-CryptX/issues"
|
||||
},
|
||||
"repository" : {
|
||||
"url" : "https://github.com/DCIT/perl-CryptX"
|
||||
}
|
||||
},
|
||||
"version" : "0.048",
|
||||
"x_serialization_backend" : "JSON::PP version 2.27400"
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
---
|
||||
abstract: 'Crypto toolkit'
|
||||
author:
|
||||
- 'Karel Miko'
|
||||
build_requires:
|
||||
ExtUtils::MakeMaker: '0'
|
||||
configure_requires:
|
||||
ExtUtils::MakeMaker: '0'
|
||||
dynamic_config: 1
|
||||
generated_by: 'ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter version 2.150010'
|
||||
license: perl
|
||||
meta-spec:
|
||||
url: http://module-build.sourceforge.net/META-spec-v1.4.html
|
||||
version: '1.4'
|
||||
name: CryptX
|
||||
no_index:
|
||||
directory:
|
||||
- t
|
||||
- inc
|
||||
requires:
|
||||
perl: '5.006'
|
||||
resources:
|
||||
bugtracker: https://github.com/DCIT/perl-CryptX/issues
|
||||
repository: https://github.com/DCIT/perl-CryptX
|
||||
version: '0.048'
|
||||
x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
use strict;
|
||||
use warnings;
|
||||
use ExtUtils::MakeMaker;
|
||||
use Config;
|
||||
|
||||
my @myobjs = map { s|.c$|$Config{obj_ext}|; $_ } grep { $_ !~ m|^src/ltc/\.*tab\.c$| } (
|
||||
glob('src/ltm/*.c'),
|
||||
glob('src/ltc/*/*.c'),
|
||||
glob('src/ltc/*/*/*.c'),
|
||||
glob('src/ltc/*/*/*/*.c'),
|
||||
glob('src/ltc/*/*/*/*/*.c'),
|
||||
);
|
||||
my $myextlib = "src/liballinone$Config{lib_ext}";
|
||||
my $mycflags = "$Config{cccdlflags} $Config{ccflags} $Config{optimize} -Iltm -Iltc/headers -DLTC_SOURCE -DLTC_NO_TEST -DLTC_NO_PROTOTYPES -DLTM_DESC";
|
||||
|
||||
#FIX: gcc with -flto is a trouble maker see https://github.com/DCIT/perl-CryptX/issues/32
|
||||
$mycflags =~ s/-flto\b//g;
|
||||
|
||||
#FIX: avoid "ar: fatal: Numeric group ID too large" see https://github.com/DCIT/perl-CryptX/issues/33
|
||||
my $myarflags = '$(AR_STATIC_ARGS)';
|
||||
if ($^O ne 'MSWin32' && $Config{ar}) {
|
||||
# for ar's "deterministic mode" we need GNU binutils 2.20+ (2009-10-16)
|
||||
my $arver = `$Config{ar} --version`;
|
||||
my ($maj, $min) = $arver =~ /^GNU ar [^\d]*(\d)\.(\d+)\.\d+/s;
|
||||
$myarflags = 'rcD' if ($maj && $min && $maj >= 2 && $min >= 20) || $arver=~ /^BSD ar /;
|
||||
}
|
||||
|
||||
my %eumm_args = (
|
||||
NAME => 'CryptX',
|
||||
VERSION_FROM => 'lib/CryptX.pm',
|
||||
AUTHOR => 'Karel Miko',
|
||||
ABSTRACT => 'Crypto toolkit',
|
||||
MIN_PERL_VERSION => '5.006',
|
||||
LICENSE => 'perl_5',
|
||||
META_MERGE => { resources => { repository => 'https://github.com/DCIT/perl-CryptX', bugtracker => 'https://github.com/DCIT/perl-CryptX/issues' } },
|
||||
DEFINE => '-DLTC_SOURCE -DLTC_NO_TEST -DLTC_NO_PROTOTYPES -DLTM_DESC',
|
||||
INC => '-Isrc/ltc/headers -Isrc/ltm',
|
||||
LIBS => [''],
|
||||
MYEXTLIB => $myextlib,
|
||||
clean => { 'FILES' => join(' ', @myobjs, $myextlib) },
|
||||
);
|
||||
|
||||
my $eumm_ver = eval $ExtUtils::MakeMaker::VERSION;
|
||||
delete $eumm_args{MIN_PERL_VERSION} if $eumm_ver < 6.48;
|
||||
delete $eumm_args{META_ADD} if $eumm_ver < 6.46;
|
||||
delete $eumm_args{META_MERGE} if $eumm_ver < 6.46;
|
||||
delete $eumm_args{LICENSE} if $eumm_ver < 6.31;
|
||||
|
||||
WriteMakefile(%eumm_args);
|
||||
|
||||
# ARFLAGS=\$(AR_STATIC_ARGS) RANLIB=\$(RANLIB) AR=\$(AR)
|
||||
|
||||
sub MY::postamble {
|
||||
my $myextlib = qq{
|
||||
\$(MYEXTLIB): src/Makefile
|
||||
cd src && \$(MAKE) ARFLAGS="$myarflags" RANLIB="\$(RANLIB)" AR="\$(AR)" CC="\$(CC)" LIB_EXT=\$(LIB_EXT) OBJ_EXT=\$(OBJ_EXT) CFLAGS="$mycflags"
|
||||
};
|
||||
|
||||
$myextlib = qq{
|
||||
\$(MYEXTLIB): src/Makefile
|
||||
cd src && \$(MAKE) -f Makefile.nmake CFLAGS="$mycflags"
|
||||
} if $^O eq 'MSWin32' && $Config{make} =~ /nmake/ && $Config{cc} =~ /cl/;
|
||||
|
||||
$myextlib = qq{
|
||||
\$(MYEXTLIB): src/Makefile
|
||||
cd src && \$(MAKE) CC="$Config{cc}" CFLAGS="$mycflags"
|
||||
} if $^O eq 'MSWin32' && $Config{cc} =~ /gcc/;
|
||||
|
||||
my $version_patch = q{
|
||||
versionsync:
|
||||
$(NOECHO) perl _generators/version_patch.pl sync
|
||||
|
||||
versioninc:
|
||||
$(NOECHO) perl _generators/version_patch.pl inc
|
||||
|
||||
versionincdev:
|
||||
$(NOECHO) perl _generators/version_patch.pl incdev
|
||||
|
||||
versiondec:
|
||||
$(NOECHO) perl _generators/version_patch.pl dec
|
||||
|
||||
versiondecdev:
|
||||
$(NOECHO) perl _generators/version_patch.pl decdev
|
||||
};
|
||||
|
||||
return "$myextlib\n$version_patch";
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
NAME
|
||||
CryptX - Crypto toolkit (self-contained no external libraries needed)
|
||||
|
||||
DESCRIPTION
|
||||
Cryptography in CryptX is based on
|
||||
<https://github.com/libtom/libtomcrypt>
|
||||
|
||||
Currently available modules:
|
||||
|
||||
* Ciphers - see Crypt::Cipher and related modules
|
||||
|
||||
Crypt::Cipher::AES, Crypt::Cipher::Anubis, Crypt::Cipher::Blowfish,
|
||||
Crypt::Cipher::Camellia, Crypt::Cipher::CAST5, Crypt::Cipher::DES,
|
||||
Crypt::Cipher::DES_EDE, Crypt::Cipher::KASUMI,
|
||||
Crypt::Cipher::Khazad, Crypt::Cipher::MULTI2,
|
||||
Crypt::Cipher::Noekeon, Crypt::Cipher::RC2, Crypt::Cipher::RC5,
|
||||
Crypt::Cipher::RC6, Crypt::Cipher::SAFERP,
|
||||
Crypt::Cipher::SAFER_K128, Crypt::Cipher::SAFER_K64,
|
||||
Crypt::Cipher::SAFER_SK128, Crypt::Cipher::SAFER_SK64,
|
||||
Crypt::Cipher::SEED, Crypt::Cipher::Skipjack,
|
||||
Crypt::Cipher::Twofish, Crypt::Cipher::XTEA
|
||||
|
||||
* Block cipher modes
|
||||
|
||||
Crypt::Mode::CBC, Crypt::Mode::CFB, Crypt::Mode::CTR,
|
||||
Crypt::Mode::ECB, Crypt::Mode::OFB
|
||||
|
||||
* Authenticated encryption modes
|
||||
|
||||
Crypt::AuthEnc::CCM, Crypt::AuthEnc::EAX, Crypt::AuthEnc::GCM,
|
||||
Crypt::AuthEnc::OCB
|
||||
|
||||
* Hash Functions - see Crypt::Digest and related modules
|
||||
|
||||
Crypt::Digest::CHAES, Crypt::Digest::MD2, Crypt::Digest::MD4,
|
||||
Crypt::Digest::MD5, Crypt::Digest::RIPEMD128,
|
||||
Crypt::Digest::RIPEMD160, Crypt::Digest::RIPEMD256,
|
||||
Crypt::Digest::RIPEMD320, Crypt::Digest::SHA1,
|
||||
Crypt::Digest::SHA224, Crypt::Digest::SHA256, Crypt::Digest::SHA384,
|
||||
Crypt::Digest::SHA512, Crypt::Digest::SHA512_224,
|
||||
Crypt::Digest::SHA512_256, Crypt::Digest::Tiger192,
|
||||
Crypt::Digest::Whirlpool
|
||||
|
||||
* Message Authentication Codes
|
||||
|
||||
Crypt::Mac::F9, Crypt::Mac::HMAC, Crypt::Mac::OMAC,
|
||||
Crypt::Mac::Pelican, Crypt::Mac::PMAC, Crypt::Mac::XCBC
|
||||
|
||||
* Public key cryptography
|
||||
|
||||
Crypt::PK::RSA, Crypt::PK::DSA, Crypt::PK::ECC, Crypt::PK::DH
|
||||
|
||||
* Cryptographically secure random number generators
|
||||
|
||||
Crypt::PRNG, Crypt::PRNG::Fortuna, Crypt::PRNG::Yarrow,
|
||||
Crypt::PRNG::RC4, Crypt::PRNG::Sober128
|
||||
|
||||
* Key derivation functions - PBKDF1, PBKFD2 and HKDF
|
||||
|
||||
Crypt::KeyDerivation
|
||||
|
||||
LICENSE
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the same terms as Perl itself.
|
||||
|
||||
COPYRIGHT
|
||||
Copyright (c) 2013-2015 DCIT, a.s. <http://www.dcit.cz> / Karel Miko
|
||||
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::AuthEnc::CCM
|
||||
|
||||
void
|
||||
_memory_encrypt(char *cipher_name, SV *key, SV *nonce, SV *header, unsigned long tag_len, SV *plaintext)
|
||||
PPCODE:
|
||||
{
|
||||
STRLEN k_len, n_len, h_len, pt_len;
|
||||
unsigned char *k, *n, *h, *pt;
|
||||
int rv, id;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
SV *ct;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
if (!SvPOK(header)) croak("FATAL: header must be string/buffer scalar");
|
||||
if (!SvPOK(plaintext)) croak("FATAL: plaintext must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
n = (unsigned char *) SvPVbyte(nonce, n_len);
|
||||
h = (unsigned char *) SvPVbyte(header, h_len);
|
||||
pt = (unsigned char *) SvPVbyte(plaintext, pt_len);
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
ct = NEWSV(0, pt_len);
|
||||
SvPOK_only(ct);
|
||||
SvCUR_set(ct, pt_len);
|
||||
|
||||
if(tag_len<4 || tag_len>16) tag_len = 16;
|
||||
|
||||
rv = ccm_memory(id, k, (unsigned long)k_len, NULL, n, (unsigned long)n_len, h, (unsigned long)h_len,
|
||||
pt, (unsigned long)pt_len, (unsigned char *)SvPV_nolen(ct), tag, &tag_len, CCM_ENCRYPT);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ccm_memory failed: %s", error_to_string(rv));
|
||||
|
||||
XPUSHs(sv_2mortal(ct));
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag,tag_len)));
|
||||
|
||||
/* int ccm_memory( int cipher,
|
||||
const unsigned char *key, unsigned long keylen,
|
||||
symmetric_key *uskey,
|
||||
const unsigned char *nonce, unsigned long noncelen,
|
||||
const unsigned char *header, unsigned long headerlen,
|
||||
unsigned char *pt, unsigned long ptlen,
|
||||
unsigned char *ct,
|
||||
unsigned char *tag, unsigned long *taglen,
|
||||
int direction); */
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
_memory_decrypt(char *cipher_name, SV *key, SV *nonce, SV *header, SV *ciphertext, SV *tag)
|
||||
PPCODE:
|
||||
{
|
||||
STRLEN k_len, n_len, h_len, ct_len, t_len;
|
||||
unsigned char *k, *n, *h, *ct, *t;
|
||||
int rv, id;
|
||||
unsigned char xtag[MAXBLOCKSIZE];
|
||||
unsigned long xtag_len;
|
||||
SV *pt;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
if (!SvPOK(header)) croak("FATAL: header must be string/buffer scalar");
|
||||
if (!SvPOK(ciphertext)) croak("FATAL: ciphertext must be string/buffer scalar");
|
||||
if (!SvPOK(tag)) croak("FATAL: tag must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
n = (unsigned char *) SvPVbyte(nonce, n_len);
|
||||
h = (unsigned char *) SvPVbyte(header, h_len);
|
||||
ct = (unsigned char *) SvPVbyte(ciphertext, ct_len);
|
||||
t = (unsigned char *) SvPVbyte(tag, t_len);
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
pt = NEWSV(0, ct_len);
|
||||
SvPOK_only(pt);
|
||||
SvCUR_set(pt, ct_len);
|
||||
|
||||
xtag_len = (unsigned long)t_len;
|
||||
Copy(t, xtag, t_len, unsigned char);
|
||||
|
||||
rv = ccm_memory(id, k, (unsigned long)k_len, NULL, n, (unsigned long)n_len, h, (unsigned long)h_len,
|
||||
(unsigned char *)SvPV_nolen(pt), (unsigned long)ct_len, ct, xtag, &xtag_len, CCM_DECRYPT);
|
||||
if (rv != CRYPT_OK) {
|
||||
XPUSHs(sv_2mortal(newSVpvn(NULL,0))); /* undef */
|
||||
}
|
||||
else {
|
||||
XPUSHs(sv_2mortal(pt));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,185 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::AuthEnc::ChaCha20Poly1305
|
||||
|
||||
Crypt::AuthEnc::ChaCha20Poly1305
|
||||
_new(SV * key, SV * nonce = NULL)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN iv_len=0, k_len=0;
|
||||
unsigned char *iv=NULL, *k=NULL;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
if (nonce) {
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
|
||||
}
|
||||
|
||||
Newz(0, RETVAL, 1, struct chacha20poly1305_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = chacha20poly1305_init(&RETVAL->state, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_init failed: %s", error_to_string(rv));
|
||||
|
||||
if (iv && iv_len > 0) {
|
||||
rv = chacha20poly1305_setiv(&RETVAL->state, iv, (unsigned long)iv_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::AuthEnc::ChaCha20Poly1305 self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::AuthEnc::ChaCha20Poly1305
|
||||
clone(Crypt::AuthEnc::ChaCha20Poly1305 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct chacha20poly1305_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct chacha20poly1305_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
set_iv(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * nonce)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN iv_len=0;
|
||||
unsigned char *iv=NULL;
|
||||
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
|
||||
rv = chacha20poly1305_setiv(&self->state, iv, (unsigned long)iv_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv failed: %s", error_to_string(rv));
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
set_iv_rfc7905(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * nonce, UV seqnum)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN iv_len=0;
|
||||
unsigned char *iv=NULL;
|
||||
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
|
||||
rv = chacha20poly1305_setiv_rfc7905(&self->state, iv, (unsigned long)iv_len, (ulong64)seqnum);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_setiv_rfc7905 failed: %s", error_to_string(rv));
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
adata_add(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
rv = chacha20poly1305_add_aad(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_add_aad failed: %s", error_to_string(rv));
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
decrypt_add(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = chacha20poly1305_decrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
encrypt_add(Crypt::AuthEnc::ChaCha20Poly1305 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = chacha20poly1305_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
encrypt_done(Crypt::AuthEnc::ChaCha20Poly1305 self)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
|
||||
rv = chacha20poly1305_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv));
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
|
||||
void
|
||||
decrypt_done(Crypt::AuthEnc::ChaCha20Poly1305 self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
STRLEN expected_tag_len;
|
||||
unsigned char *expected_tag;
|
||||
|
||||
rv = chacha20poly1305_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha20poly1305_done failed: %s", error_to_string(rv));
|
||||
if (items == 1) {
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
else {
|
||||
if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
|
||||
expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
|
||||
if (expected_tag_len!=tag_len) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else if (memNE(expected_tag, tag, tag_len)) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else {
|
||||
XPUSHs(sv_2mortal(newSViv(1))); /* true */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,152 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::AuthEnc::EAX
|
||||
|
||||
Crypt::AuthEnc::EAX
|
||||
_new(char * cipher_name, SV * key, SV * nonce, SV * adata=&PL_sv_undef)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
unsigned char *n=NULL;
|
||||
STRLEN n_len=0;
|
||||
unsigned char *h=NULL;
|
||||
STRLEN h_len=0;
|
||||
int id;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
n = (unsigned char *) SvPVbyte(nonce, n_len);
|
||||
if(SvOK(adata)) { /* adata is optional param */
|
||||
if(!SvPOK(adata)) croak("FATAL: adata must be string/buffer scalar");
|
||||
h = (unsigned char *) SvPVbyte(adata, h_len);
|
||||
}
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
Newz(0, RETVAL, 1, struct eax_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
if (eax_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len, h, (unsigned long)h_len) != CRYPT_OK) {
|
||||
croak("FATAL: eax setup failed");
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::AuthEnc::EAX self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::AuthEnc::EAX
|
||||
clone(Crypt::AuthEnc::EAX self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct eax_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct eax_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
encrypt_add(Crypt::AuthEnc::EAX self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = eax_encrypt(&self->state, in_data, out_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: eax_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
decrypt_add(Crypt::AuthEnc::EAX self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = eax_decrypt(&self->state, in_data, out_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: eax_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
encrypt_done(Crypt::AuthEnc::EAX self)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
|
||||
rv = eax_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv));
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
|
||||
void
|
||||
decrypt_done(Crypt::AuthEnc::EAX self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
STRLEN expected_tag_len;
|
||||
unsigned char *expected_tag;
|
||||
|
||||
rv = eax_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: eax_done failed: %s", error_to_string(rv));
|
||||
if (items == 1) {
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
else {
|
||||
if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
|
||||
expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
|
||||
if (expected_tag_len!=tag_len) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else if (memNE(expected_tag, tag, tag_len)) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else {
|
||||
XPUSHs(sv_2mortal(newSViv(1))); /* true */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
aad_add(Crypt::AuthEnc::EAX self, SV * adata)
|
||||
CODE:
|
||||
{
|
||||
STRLEN h_len;
|
||||
unsigned char *h;
|
||||
h = (unsigned char *)SvPVbyte(adata, h_len);
|
||||
RETVAL = eax_addheader(&self->state, h, (unsigned long)h_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::AuthEnc::GCM
|
||||
|
||||
Crypt::AuthEnc::GCM
|
||||
_new(char * cipher_name, SV * key, SV * nonce = NULL)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len = 0, iv_len = 0;
|
||||
unsigned char *k = NULL, *iv = NULL;
|
||||
int id, rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
if (nonce) {
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
iv = (unsigned char *)SvPVbyte(nonce, iv_len);
|
||||
}
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if (id == -1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
Newz(0, RETVAL, 1, struct gcm_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = gcm_init(&RETVAL->state, id, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_init failed: %s", error_to_string(rv));
|
||||
|
||||
if (iv && iv_len > 0) {
|
||||
rv = gcm_add_iv(&RETVAL->state, iv, (unsigned long)iv_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::AuthEnc::GCM self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::AuthEnc::GCM
|
||||
clone(Crypt::AuthEnc::GCM self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct gcm_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct gcm_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
reset(Crypt::AuthEnc::GCM self)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
rv = gcm_reset(&self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_reset failed: %s", error_to_string(rv));
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
encrypt_add(Crypt::AuthEnc::GCM self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = gcm_process(&self->state, in_data, (unsigned long)in_data_len, out_data, GCM_ENCRYPT);
|
||||
if (rv != CRYPT_OK) croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
iv_add(Crypt::AuthEnc::GCM self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
rv = gcm_add_iv(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_add_iv failed: %s", error_to_string(rv));
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
adata_add(Crypt::AuthEnc::GCM self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
rv = gcm_add_aad(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_add_aad failed: %s", error_to_string(rv));
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
decrypt_add(Crypt::AuthEnc::GCM self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = gcm_process(&self->state, out_data, (unsigned long)in_data_len, in_data, GCM_DECRYPT);
|
||||
if (rv != CRYPT_OK) croak("FATAL: encrypt_add/gcm_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
|
||||
void
|
||||
encrypt_done(Crypt::AuthEnc::GCM self)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
|
||||
rv = gcm_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv));
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
|
||||
void
|
||||
decrypt_done(Crypt::AuthEnc::GCM self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
STRLEN expected_tag_len;
|
||||
unsigned char *expected_tag;
|
||||
|
||||
rv = gcm_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: gcm_done failed: %s", error_to_string(rv));
|
||||
if (items == 1) {
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
else {
|
||||
if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
|
||||
expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
|
||||
if (expected_tag_len!=tag_len) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else if (memNE(expected_tag, tag, tag_len)) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else {
|
||||
XPUSHs(sv_2mortal(newSViv(1))); /* true */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,218 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::AuthEnc::OCB
|
||||
|
||||
Crypt::AuthEnc::OCB
|
||||
_new(char * cipher_name, SV * key, SV * nonce)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
unsigned char *n=NULL;
|
||||
STRLEN n_len=0;
|
||||
int id;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
n = (unsigned char *) SvPVbyte(nonce, n_len);
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
Newz(0, RETVAL, 1, struct ocb_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
if (ocb3_init(&RETVAL->state, id, k, (unsigned long)k_len, n, (unsigned long)n_len) != CRYPT_OK) {
|
||||
croak("FATAL: ocb setup failed");
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::AuthEnc::OCB self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::AuthEnc::OCB
|
||||
clone(Crypt::AuthEnc::OCB self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct ocb_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct ocb_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
aad_add(Crypt::AuthEnc::OCB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
|
||||
if (in_data_len>0) {
|
||||
rv = ocb3_add_aad(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_add_aad failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
encrypt_add(Crypt::AuthEnc::OCB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (in_data_len % (&self->state)->block_len)
|
||||
croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
|
||||
|
||||
rv = ocb3_encrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
encrypt_last(Crypt::AuthEnc::OCB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
}
|
||||
else {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
out_data = NULL;
|
||||
}
|
||||
rv = ocb3_encrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
decrypt_add(Crypt::AuthEnc::OCB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (in_data_len % (&self->state)->block_len)
|
||||
croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", (&self->state)->block_len);
|
||||
|
||||
rv = ocb3_decrypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
decrypt_last(Crypt::AuthEnc::OCB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
}
|
||||
else {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
out_data = NULL;
|
||||
}
|
||||
rv = ocb3_decrypt_last(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_encrypt_last failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
encrypt_done(Crypt::AuthEnc::OCB self)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
|
||||
rv = ocb3_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_done_encrypt failed: %s", error_to_string(rv));
|
||||
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
|
||||
void
|
||||
decrypt_done(Crypt::AuthEnc::OCB self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char tag[MAXBLOCKSIZE];
|
||||
unsigned long tag_len = sizeof(tag);
|
||||
STRLEN expected_tag_len;
|
||||
unsigned char *expected_tag;
|
||||
|
||||
rv = ocb3_done(&self->state, tag, &tag_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ocb3_done_decrypt failed: %s", error_to_string(rv));
|
||||
if (items == 1) {
|
||||
XPUSHs(sv_2mortal(newSVpvn((char*)tag, tag_len)));
|
||||
}
|
||||
else {
|
||||
if(!SvPOK(ST(1))) croak("FATAL: expected_tag must be string/buffer scalar");
|
||||
expected_tag = (unsigned char *) SvPVbyte(ST(1), expected_tag_len);
|
||||
if (expected_tag_len!=tag_len) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else if (memNE(expected_tag, tag, tag_len)) {
|
||||
XPUSHs(sv_2mortal(newSViv(0))); /* false */
|
||||
}
|
||||
else {
|
||||
XPUSHs(sv_2mortal(newSViv(1))); /* true */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
blocksize(Crypt::AuthEnc::OCB self)
|
||||
CODE:
|
||||
{
|
||||
RETVAL = (&self->state)->block_len;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,658 @@
|
|||
MODULE = CryptX PACKAGE = Math::BigInt::LTM
|
||||
|
||||
|
||||
##############################################################################
|
||||
# _new()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_new(Class, SV *x)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
if ((SvUOK(x) || SvIOK(x)) && (sizeof(UV) <= sizeof(unsigned long) || SvUV(x) == (unsigned long)SvUV(x))) {
|
||||
mp_set_int(RETVAL, (unsigned long)SvUV(x));
|
||||
}
|
||||
else {
|
||||
mp_read_radix(RETVAL, SvPV_nolen(x), 10);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _from_bin()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_from_bin(Class, SV *x)
|
||||
PREINIT:
|
||||
char *str, *start;
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
str = SvPV_nolen(x);
|
||||
start = (strlen(str)>2 && str[0] == '0' && str[1] == 'b') ? str+2 : str;
|
||||
mp_read_radix(RETVAL, start, 2);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _from_hex()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_from_hex(Class, SV *x)
|
||||
PREINIT:
|
||||
char *str, *start;
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
str = SvPV_nolen(x);
|
||||
start = (strlen(str)>2 && str[0] == '0' && str[1] == 'x') ? str+2 : str;
|
||||
mp_read_radix(RETVAL, start, 16);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _from_oct()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_from_oct(Class, SV *x)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_read_radix(RETVAL, SvPV_nolen(x), 8);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _set() - set an already existing object to the given scalar value
|
||||
|
||||
void
|
||||
_set(Class, Math::BigInt::LTM n, SV *x)
|
||||
CODE:
|
||||
mp_set_int(n, (unsigned long)SvIV(x));
|
||||
|
||||
##############################################################################
|
||||
# _zero()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_zero(Class)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_set_int(RETVAL, 0);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _one()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_one(Class)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_set_int(RETVAL, 1);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _two()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_two(Class)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_set_int(RETVAL, 2);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _ten()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_ten(Class)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_set_int(RETVAL, 10);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _1ex()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_1ex(Class, int x)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_set_int(RETVAL, 10);
|
||||
mp_expt_d(RETVAL, x, RETVAL);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# DESTROY() - free memory of a GMP number
|
||||
|
||||
void
|
||||
DESTROY(Math::BigInt::LTM n)
|
||||
PPCODE:
|
||||
if (n) {
|
||||
mp_clear(n);
|
||||
Safefree(n);
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# _str() - return string so that atof() and atoi() can use it
|
||||
|
||||
SV *
|
||||
_str(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int len;
|
||||
char *buf;
|
||||
CODE:
|
||||
if (mp_iszero(n) == MP_YES) {
|
||||
RETVAL = newSVpv("0", 0);
|
||||
}
|
||||
else {
|
||||
len = mp_count_bits(n) / 3 + 3; /* decimal_size ~ (binary_size/3 + 1) +1 for sign +1 for NUL-byte */
|
||||
Newz(0, buf, len, char);
|
||||
mp_toradix_n(n, buf, 10, len);
|
||||
RETVAL = newSVpv(buf, 0);
|
||||
Safefree(buf);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _len() - return the length of the number in base 10 (costly)
|
||||
|
||||
int
|
||||
_len(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int len;
|
||||
char *buf;
|
||||
CODE:
|
||||
if (mp_iszero(n) == MP_YES) {
|
||||
RETVAL = 1;
|
||||
}
|
||||
else {
|
||||
len = mp_count_bits(n) / 3 + 3; /* decimal_size ~ (binary_size/3 + 1) +1 for sign +1 for NUL-byte */
|
||||
Newz(0, buf, len, char);
|
||||
mp_toradix_n(n, buf, 10, len);
|
||||
RETVAL = (int)strlen(buf);
|
||||
Safefree(buf);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _alen() - return the approx. length of the number in base 10 (fast)
|
||||
# _alen() might underestimate, but never overestimate the true value
|
||||
int
|
||||
_alen(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int bits;
|
||||
CODE:
|
||||
bits = mp_count_bits(n);
|
||||
/* alen = round(bits * log(2) / log(10)) */
|
||||
RETVAL = (bits < 5) ? 1 : (int)(bits * 0.301029995663 + 0.499999999999);
|
||||
/* less accurate approximation, but without floating-point calculations
|
||||
RETVAL = (bits < 5) ? 1 : bits / 4 + bits / 32 + bits / 64 + bits / 256;
|
||||
RETVAL = (bits < 5) ? 1 : bits / 4;
|
||||
*/
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _zeros() - return number of trailing zeros (in decimal form)
|
||||
|
||||
int
|
||||
_zeros(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int len;
|
||||
char *buf;
|
||||
CODE:
|
||||
if (mp_iszero(n) == MP_YES) {
|
||||
RETVAL = 0; /* '0' has no trailing zeros! */
|
||||
}
|
||||
else {
|
||||
len = mp_count_bits(n) / 3 + 3; /* decimal_size ~ (binary_size/3 + 1) +1 for sign +1 for NUL-byte */
|
||||
Newz(0, buf, len, char);
|
||||
mp_toradix_n(n, buf, 10, len);
|
||||
len = (int)strlen(buf);
|
||||
RETVAL = 0;
|
||||
while (len > 0) {
|
||||
if (buf[len-1] != '0') break;
|
||||
RETVAL++;
|
||||
len--;
|
||||
}
|
||||
Safefree(buf);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _as_hex() - return ref to hexadecimal string (prefixed with 0x)
|
||||
|
||||
SV *
|
||||
_as_hex(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int i, len;
|
||||
char *buf;
|
||||
CODE:
|
||||
len = mp_unsigned_bin_size(n) * 2 + 3;
|
||||
RETVAL = newSV(len);
|
||||
SvPOK_on(RETVAL);
|
||||
buf = SvPVX(RETVAL); /* get ptr to storage */
|
||||
*buf++ = '0'; *buf++ = 'x'; /* prepend '0x' */
|
||||
mp_tohex(n, buf);
|
||||
for (i=0; i<len && buf[i]>0; i++) buf[i] = toLOWER(buf[i]);
|
||||
SvCUR_set(RETVAL, strlen(buf)+2); /* set real length */
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _as_bin() - return ref to binary string (prefixed with 0b)
|
||||
|
||||
SV *
|
||||
_as_bin(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int len;
|
||||
char *buf;
|
||||
CODE:
|
||||
len = mp_unsigned_bin_size(n) * 8 + 3;
|
||||
RETVAL = newSV(len);
|
||||
SvPOK_on(RETVAL);
|
||||
buf = SvPVX(RETVAL); /* get ptr to storage */
|
||||
*buf++ = '0'; *buf++ = 'b'; /* prepend '0b' */
|
||||
mp_tobinary(n, buf);
|
||||
SvCUR_set(RETVAL, strlen(buf)+2); /* set real length */
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _as_oct() - return ref to octal string (prefixed with 0)
|
||||
|
||||
SV *
|
||||
_as_oct(Class, Math::BigInt::LTM n)
|
||||
PREINIT:
|
||||
int len;
|
||||
char *buf;
|
||||
CODE:
|
||||
len = mp_unsigned_bin_size(n) * 3 + 3;
|
||||
RETVAL = newSV(len);
|
||||
SvPOK_on(RETVAL);
|
||||
buf = SvPVX(RETVAL);
|
||||
*buf++ = '0'; /* prepend '0' */
|
||||
mp_tooctal(n, buf);
|
||||
SvCUR_set(RETVAL, strlen(buf)+1); /* set real length */
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _modpow() - ($n ** $exp) % $mod
|
||||
|
||||
Math::BigInt::LTM
|
||||
_modpow(Class, Math::BigInt::LTM n, Math::BigInt::LTM exp, Math::BigInt::LTM mod)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
if (mp_cmp_d(mod, 1) == MP_EQ) {
|
||||
mp_set_int(RETVAL, 0);
|
||||
}
|
||||
else {
|
||||
mp_exptmod(n, exp, mod, RETVAL);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _modinv() - compute the inverse of x % y
|
||||
|
||||
void
|
||||
_modinv(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PREINIT:
|
||||
int rc;
|
||||
SV* s;
|
||||
mp_int* RETVAL;
|
||||
PPCODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
rc = mp_invmod(x, y, RETVAL);
|
||||
EXTEND(SP, 2); /* we return two values */
|
||||
if (rc != MP_OKAY) {
|
||||
/* Inverse doesn't exist. Return both values undefined. */
|
||||
PUSHs(&PL_sv_undef);
|
||||
PUSHs(&PL_sv_undef);
|
||||
}
|
||||
else {
|
||||
/* Inverse exists. When the modulus to mp_invert() is positive,
|
||||
* the returned value is also positive. */
|
||||
PUSHs(sv_2mortal(sv_from_mpi(RETVAL)));
|
||||
s = sv_newmortal();
|
||||
sv_setpvn(s, "+", 1);
|
||||
PUSHs(s);
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# _add() - add $y to $x in place
|
||||
|
||||
void
|
||||
_add(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_add(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _inc() - modify x inline by doing x++
|
||||
|
||||
void
|
||||
_inc(Class, Math::BigInt::LTM x)
|
||||
PPCODE:
|
||||
mp_add_d(x, 1, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _dec() - modify x inline by doing x--
|
||||
|
||||
void
|
||||
_dec(Class, Math::BigInt::LTM x)
|
||||
PPCODE:
|
||||
mp_sub_d(x, 1, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _sub() - $x - $y
|
||||
# $x is always larger than $y! So overflow/underflow can not happen here.
|
||||
|
||||
void
|
||||
_sub(Class, Math::BigInt::LTM x, Math::BigInt::LTM y, ...)
|
||||
PPCODE:
|
||||
if ( items == 4 && SvTRUE(ST(3)) ) {
|
||||
/* y -= x */
|
||||
mp_sub(x, y, y);
|
||||
XPUSHs(ST(2)); /* y */
|
||||
}
|
||||
else {
|
||||
/* x -= y */
|
||||
mp_sub(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# _rsft()
|
||||
|
||||
void
|
||||
_rsft(Class, Math::BigInt::LTM x, Math::BigInt::LTM y, unsigned long base_int)
|
||||
PREINIT:
|
||||
mp_int* BASE;
|
||||
PPCODE:
|
||||
Newz(0, BASE, 1, mp_int);
|
||||
mp_init_set_int(BASE, base_int);
|
||||
mp_expt_d(BASE, mp_get_long(y), BASE);
|
||||
mp_div(x, BASE, x, NULL);
|
||||
mp_clear(BASE);
|
||||
Safefree(BASE);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _lsft()
|
||||
|
||||
void
|
||||
_lsft(Class, Math::BigInt::LTM x, Math::BigInt::LTM y, unsigned long base_int)
|
||||
PREINIT:
|
||||
mp_int* BASE;
|
||||
PPCODE:
|
||||
Newz(0, BASE, 1, mp_int);
|
||||
mp_init_set_int(BASE, base_int);
|
||||
mp_expt_d(BASE, mp_get_long(y), BASE);
|
||||
mp_mul(x, BASE, x);
|
||||
mp_clear(BASE);
|
||||
Safefree(BASE);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _mul()
|
||||
|
||||
void
|
||||
_mul(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_mul(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _div(): x /= y or (x,rem) = x / y
|
||||
|
||||
void
|
||||
_div(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PREINIT:
|
||||
mp_int * rem;
|
||||
PPCODE:
|
||||
if (GIMME_V == G_ARRAY) {
|
||||
Newz(0, rem, 1, mp_int);
|
||||
mp_init(rem);
|
||||
mp_div(x, y, x, rem);
|
||||
EXTEND(SP, 2);
|
||||
PUSHs(ST(1)); /* x */
|
||||
PUSHs(sv_2mortal(sv_from_mpi(rem)));
|
||||
}
|
||||
else {
|
||||
mp_div(x, y, x, NULL);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# _mod() - x %= y
|
||||
|
||||
void
|
||||
_mod(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_mod(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _acmp() - cmp two numbers
|
||||
|
||||
int
|
||||
_acmp(Class, Math::BigInt::LTM m, Math::BigInt::LTM n)
|
||||
CODE:
|
||||
RETVAL = mp_cmp(m, n);
|
||||
if ( RETVAL < 0) RETVAL = -1;
|
||||
if ( RETVAL > 0) RETVAL = 1;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _is_zero()
|
||||
|
||||
int
|
||||
_is_zero(Class, Math::BigInt::LTM x)
|
||||
CODE:
|
||||
RETVAL = (mp_iszero(x) == MP_YES) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _is_one()
|
||||
|
||||
int
|
||||
_is_one(Class, Math::BigInt::LTM x)
|
||||
CODE:
|
||||
RETVAL = (mp_cmp_d(x, 1) == MP_EQ) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _is_two()
|
||||
|
||||
int
|
||||
_is_two(Class, Math::BigInt::LTM x)
|
||||
CODE:
|
||||
RETVAL = (mp_cmp_d(x, 2) == MP_EQ) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _is_ten()
|
||||
|
||||
int
|
||||
_is_ten(Class, Math::BigInt::LTM x)
|
||||
CODE:
|
||||
RETVAL = (mp_cmp_d(x, 10) == MP_EQ) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _pow() - x **= y
|
||||
|
||||
void
|
||||
_pow(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_expt_d(x, mp_get_long(y), x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _gcd() - gcd(m,n)
|
||||
|
||||
Math::BigInt::LTM
|
||||
_gcd(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_gcd(x, y, RETVAL);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _and() - m &= n
|
||||
|
||||
void
|
||||
_and(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_and(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _xor() - m =^ n
|
||||
|
||||
void
|
||||
_xor(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_xor(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _or() - m =| n
|
||||
|
||||
void
|
||||
_or(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_or(x, y, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _copy()
|
||||
|
||||
Math::BigInt::LTM
|
||||
_copy(Class, Math::BigInt::LTM m)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, mp_int);
|
||||
mp_init(RETVAL);
|
||||
mp_copy(m, RETVAL);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _is_odd() - test for number being odd
|
||||
|
||||
int
|
||||
_is_odd(Class, Math::BigInt::LTM n)
|
||||
CODE:
|
||||
RETVAL = (mp_isodd(n) == MP_YES) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _is_even() - test for number being even
|
||||
|
||||
int
|
||||
_is_even(Class, Math::BigInt::LTM n)
|
||||
CODE:
|
||||
RETVAL = (mp_iseven(n) == MP_YES || mp_iszero(n) == MP_YES) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
##############################################################################
|
||||
# _sqrt() - square root
|
||||
|
||||
void
|
||||
_sqrt(Class, Math::BigInt::LTM x)
|
||||
PPCODE:
|
||||
mp_sqrt(x, x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _root() - integer roots
|
||||
|
||||
void
|
||||
_root(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_n_root(x, mp_get_long(y), x);
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# _lcm() - least common multiple
|
||||
void
|
||||
_lcm(Class, Math::BigInt::LTM x, Math::BigInt::LTM y)
|
||||
PPCODE:
|
||||
mp_lcm(x, y, x) ;
|
||||
XPUSHs(ST(1)); /* x */
|
||||
|
||||
##############################################################################
|
||||
# Storable hooks
|
||||
|
||||
void
|
||||
STORABLE_thaw(blank_obj, cloning, serialized, ...)
|
||||
SV *blank_obj
|
||||
SV *cloning = NO_INIT
|
||||
SV *serialized
|
||||
PREINIT:
|
||||
SV *target;
|
||||
mp_int *mpi;
|
||||
PPCODE:
|
||||
PERL_UNUSED_VAR(cloning);
|
||||
if (SvROK(blank_obj) && sv_isa(blank_obj, "Math::BigInt::LTM")) {
|
||||
Newz(0, mpi, 1, mp_int);
|
||||
mp_init(mpi);
|
||||
mp_read_radix(mpi, SvPV_nolen(serialized), 10);
|
||||
target = SvRV(blank_obj);
|
||||
SvIV_set(target, PTR2IV(mpi));
|
||||
SvIOK_on(target);
|
||||
PUSHs(target);
|
||||
XSRETURN(1);
|
||||
}
|
||||
else
|
||||
croak("Bad object for Math::BigInt::LTM::STORABLE_thaw call");
|
||||
|
||||
SV *
|
||||
STORABLE_freeze(self, cloning = NULL)
|
||||
Math::BigInt::LTM self
|
||||
SV *cloning = NO_INIT
|
||||
PREINIT:
|
||||
unsigned long len;
|
||||
char *buf;
|
||||
CODE:
|
||||
PERL_UNUSED_VAR(cloning);
|
||||
if (mp_iszero(self) == MP_YES) {
|
||||
RETVAL = newSVpv("0", 0);
|
||||
}
|
||||
else {
|
||||
len = mp_count_bits(self) / 3 + 3; /* decimal_size ~ (binary_size/3 + 1) +1 for sign +1 for NUL-byte */
|
||||
Newz(0, buf, len, char);
|
||||
mp_toradix_n(self, buf, 10, len);
|
||||
RETVAL = newSVpv(buf, 0);
|
||||
Safefree(buf);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Checksum::Adler32
|
||||
|
||||
Crypt::Checksum::Adler32
|
||||
new(Class)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, adler32_state);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
adler32_init(RETVAL);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Checksum::Adler32 self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
void
|
||||
reset(Crypt::Checksum::Adler32 self)
|
||||
CODE:
|
||||
adler32_init(self);
|
||||
|
||||
Crypt::Checksum::Adler32
|
||||
clone(Crypt::Checksum::Adler32 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, adler32_state);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(self, RETVAL, 1, adler32_state);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
add(Crypt::Checksum::Adler32 self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
STRLEN inlen;
|
||||
int i;
|
||||
unsigned char *in;
|
||||
for(i=1; i<items; i++) {
|
||||
in = (unsigned char *)SvPVbyte(ST(i), inlen);
|
||||
if (inlen>0) adler32_update(self, in, (unsigned long)inlen);
|
||||
}
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
SV *
|
||||
digest(Crypt::Checksum::Adler32 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char hash[4];
|
||||
adler32_finish(self, hash, 4);
|
||||
RETVAL = newSVpvn((char *) hash, 4);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexdigest(Crypt::Checksum::Adler32 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned long i;
|
||||
unsigned char hash[4];
|
||||
char hash_hex[4*2 + 1];
|
||||
adler32_finish(self, hash, 4);
|
||||
hash_hex[0] = '\0';
|
||||
for(i=0; i<4; i++) sprintf(&hash_hex[2*i], "%02x", hash[i]);
|
||||
RETVAL = newSVpvn(hash_hex, strlen(hash_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Checksum::CRC32
|
||||
|
||||
Crypt::Checksum::CRC32
|
||||
new(Class)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, crc32_state);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
crc32_init(RETVAL);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Checksum::CRC32 self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
void
|
||||
reset(Crypt::Checksum::CRC32 self)
|
||||
CODE:
|
||||
crc32_init(self);
|
||||
|
||||
Crypt::Checksum::CRC32
|
||||
clone(Crypt::Checksum::CRC32 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, crc32_state);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(self, RETVAL, 1, crc32_state);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
add(Crypt::Checksum::CRC32 self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
STRLEN inlen;
|
||||
int i;
|
||||
unsigned char *in;
|
||||
for(i=1; i<items; i++) {
|
||||
in = (unsigned char *)SvPVbyte(ST(i), inlen);
|
||||
if (inlen>0) crc32_update(self, in, (unsigned long)inlen);
|
||||
}
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
SV *
|
||||
digest(Crypt::Checksum::CRC32 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char hash[4];
|
||||
crc32_finish(self, hash, 4);
|
||||
RETVAL = newSVpvn((char *) hash, 4);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexdigest(Crypt::Checksum::CRC32 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned long i;
|
||||
unsigned char hash[4];
|
||||
char hash_hex[4*2 + 1];
|
||||
crc32_finish(self, hash, 4);
|
||||
hash_hex[0] = '\0';
|
||||
for(i=0; i<4; i++) sprintf(&hash_hex[2*i], "%02x", hash[i]);
|
||||
RETVAL = newSVpvn(hash_hex, strlen(hash_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
|
|
@ -0,0 +1,188 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Cipher
|
||||
|
||||
Crypt::Cipher
|
||||
_new(cipher_name, key, rounds=0)
|
||||
char * cipher_name
|
||||
SV * key
|
||||
int rounds
|
||||
CODE:
|
||||
{
|
||||
STRLEN key_len;
|
||||
unsigned char *key_data=NULL;
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
if (!SvPOK (key)) croak("FATAL: key must be string scalar");
|
||||
key_data = (unsigned char *)SvPVbyte(key, key_len);
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
Newz(0, RETVAL, 1, struct cipher_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
RETVAL->id = id;
|
||||
RETVAL->desc = &cipher_descriptor[id];
|
||||
rv = RETVAL->desc->setup(key_data, (int)key_len, rounds, &RETVAL->skey);
|
||||
if(rv!=CRYPT_OK) croak("FATAL: cipher setup failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(self)
|
||||
Crypt::Cipher self
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
int
|
||||
_max_keysize(self, ...)
|
||||
Crypt::Cipher self
|
||||
CODE:
|
||||
RETVAL = self->desc->max_key_length;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_min_keysize(self, ...)
|
||||
Crypt::Cipher self
|
||||
CODE:
|
||||
RETVAL = self->desc->min_key_length;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_blocksize(self, ...)
|
||||
Crypt::Cipher self
|
||||
CODE:
|
||||
RETVAL = self->desc->block_length;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_default_rounds(self, ...)
|
||||
Crypt::Cipher self
|
||||
CODE:
|
||||
RETVAL = self->desc->default_rounds;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
encrypt(self, data)
|
||||
Crypt::Cipher self
|
||||
SV * data
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN len;
|
||||
void *plaintext = SvPVbyte(data, len);
|
||||
|
||||
if (len==0)
|
||||
RETVAL = newSVpvn("", 0);
|
||||
else if (len % self->desc->block_length)
|
||||
croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", self->desc->block_length);
|
||||
else {
|
||||
/* idea from Crypt::Rijndael */
|
||||
RETVAL = NEWSV(0, len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, len);
|
||||
rv = self->desc->ecb_encrypt((unsigned char *)plaintext, (unsigned char *)SvPV_nolen(RETVAL), &self->skey);
|
||||
if (rv!=CRYPT_OK) croak("FATAL: encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
decrypt(self, data)
|
||||
Crypt::Cipher self
|
||||
SV * data
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN len;
|
||||
void *ciphertext = SvPVbyte(data, len);
|
||||
|
||||
if (len==0)
|
||||
RETVAL = newSVpvn("", 0);
|
||||
else if (len % self->desc->block_length)
|
||||
croak ("FATAL: sizeof(data) should be multiple of blocksize (%d)", self->desc->block_length);
|
||||
else {
|
||||
/* idea from Crypt::Rijndael */
|
||||
RETVAL = NEWSV(0, len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, len);
|
||||
rv = self->desc->ecb_decrypt((unsigned char *)ciphertext, (unsigned char *)SvPV_nolen(RETVAL), &self->skey);
|
||||
if (rv!=CRYPT_OK) croak("FATAL: decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_block_length_by_name(cipher_name)
|
||||
char * cipher_name
|
||||
CODE:
|
||||
{
|
||||
int rv, id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
rv = cipher_descriptor[id].block_length;
|
||||
if (!rv) XSRETURN_UNDEF;
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_min_key_length_by_name(cipher_name)
|
||||
char * cipher_name
|
||||
CODE:
|
||||
{
|
||||
int rv, id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
rv = cipher_descriptor[id].min_key_length;
|
||||
if (!rv) XSRETURN_UNDEF;
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_max_key_length_by_name(cipher_name)
|
||||
char * cipher_name
|
||||
CODE:
|
||||
{
|
||||
int rv, id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
rv = cipher_descriptor[id].max_key_length;
|
||||
if (!rv) XSRETURN_UNDEF;
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_default_rounds_by_name(cipher_name)
|
||||
char * cipher_name
|
||||
CODE:
|
||||
{
|
||||
int rv, id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
rv = cipher_descriptor[id].default_rounds;
|
||||
if (!rv) XSRETURN_UNDEF;
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,169 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Digest
|
||||
|
||||
Crypt::Digest
|
||||
_new(digest_name)
|
||||
char * digest_name
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
id = find_hash(digest_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", digest_name);
|
||||
|
||||
Newz(0, RETVAL, 1, struct digest_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
RETVAL->id = id;
|
||||
RETVAL->desc = &hash_descriptor[id];
|
||||
rv = RETVAL->desc->init(&RETVAL->state);
|
||||
if(rv!=CRYPT_OK) croak("FATAL: digest setup failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
void
|
||||
reset(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
rv = self->desc->init(&self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: digest init failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
Crypt::Digest
|
||||
clone(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct digest_struct);
|
||||
Copy(&self->state, &RETVAL->state, 1, struct digest_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
add(Crypt::Digest self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
STRLEN inlen;
|
||||
int rv, i;
|
||||
unsigned char *in;
|
||||
|
||||
for(i=1; i<items; i++) {
|
||||
in = (unsigned char *)SvPVbyte(ST(i), inlen);
|
||||
if (inlen>0) {
|
||||
rv = self->desc->process(&self->state, in, (unsigned long)inlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: digest process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
SV *
|
||||
digest(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
{
|
||||
unsigned char hash[MAXBLOCKSIZE];
|
||||
int rv;
|
||||
|
||||
rv = self->desc->done(&self->state, hash);
|
||||
if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char *) hash, self->desc->hashsize);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexdigest(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned long i;
|
||||
unsigned char hash[MAXBLOCKSIZE];
|
||||
char hash_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
rv = self->desc->done(&self->state, hash);
|
||||
if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
|
||||
|
||||
hash_hex[0] = '\0';
|
||||
for(i=0; i<self->desc->hashsize; i++)
|
||||
sprintf(&hash_hex[2*i], "%02x", hash[i]);
|
||||
RETVAL = newSVpvn(hash_hex, strlen(hash_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64digest(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
unsigned char hash[MAXBLOCKSIZE];
|
||||
char hash_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
rv = self->desc->done(&self->state, hash);
|
||||
if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
|
||||
|
||||
outlen = sizeof(hash_base64);
|
||||
rv = base64_encode(hash, self->desc->hashsize, (unsigned char *)hash_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(hash_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64udigest(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
unsigned char hash[MAXBLOCKSIZE];
|
||||
char hash_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
rv = self->desc->done(&self->state, hash);
|
||||
if (rv != CRYPT_OK) croak("FATAL: digest done failed: %s", error_to_string(rv));
|
||||
|
||||
outlen = sizeof(hash_base64);
|
||||
rv = base64url_encode(hash, self->desc->hashsize, (unsigned char *)hash_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(hash_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_hashsize(self)
|
||||
Crypt::Digest self
|
||||
CODE:
|
||||
RETVAL = self->desc->hashsize;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_hashsize_by_name(digest_name)
|
||||
char * digest_name
|
||||
CODE:
|
||||
{
|
||||
int rv, id;
|
||||
|
||||
id = find_hash(digest_name);
|
||||
if(id==-1) croak("FATAL: find_digest failed for '%s'", digest_name);
|
||||
|
||||
rv = hash_descriptor[id].hashsize;
|
||||
if (!rv) croak("FATAL: invalid hashsize for '%s'", digest_name);;
|
||||
RETVAL = rv;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Digest::SHAKE
|
||||
|
||||
Crypt::Digest::SHAKE
|
||||
_new(int num)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
|
||||
Newz(0, RETVAL, 1, struct digest_shake_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
RETVAL->num = num;
|
||||
rv = sha3_shake_init(&RETVAL->state, RETVAL->num);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sha3_shake_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Digest::SHAKE self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
void
|
||||
reset(Crypt::Digest::SHAKE self)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
rv = sha3_shake_init(&self->state, self->num);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sha3_shake_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
Crypt::Digest::SHAKE
|
||||
clone(Crypt::Digest::SHAKE self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct digest_shake_struct);
|
||||
Copy(&self->state, &RETVAL->state, 1, struct digest_shake_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
add(Crypt::Digest::SHAKE self, ...)
|
||||
PPCODE:
|
||||
{
|
||||
STRLEN inlen;
|
||||
int rv, i;
|
||||
unsigned char *in;
|
||||
|
||||
for(i=1; i<items; i++) {
|
||||
in = (unsigned char *)SvPVbyte(ST(i), inlen);
|
||||
if (inlen>0) {
|
||||
rv = sha3_shake_process(&self->state, in, (unsigned long)inlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sha3_shake_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
SV *
|
||||
done(Crypt::Digest::SHAKE self, STRLEN out_len)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *out_data;
|
||||
|
||||
RETVAL = NEWSV(0, out_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, out_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = sha3_shake_done(&self->state, out_data, out_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sha3_shake_done failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,181 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::KeyDerivation
|
||||
|
||||
SV *
|
||||
_pkcs_5_alg1(SV * password, SV * salt, int iteration_count, char * hash_name, int len)
|
||||
CODE:
|
||||
{
|
||||
/*
|
||||
int pkcs_5_alg1(const unsigned char *password, unsigned long password_len,
|
||||
const unsigned char *salt,
|
||||
int iteration_count, int hash_idx,
|
||||
unsigned char *out, unsigned long *outlen)
|
||||
*/
|
||||
int rv, id;
|
||||
unsigned long output_len;
|
||||
unsigned char *output;
|
||||
unsigned char *password_ptr=NULL;
|
||||
STRLEN password_len=0;
|
||||
unsigned char *salt_ptr=NULL;
|
||||
STRLEN salt_len=0;
|
||||
|
||||
id = find_hash(hash_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
|
||||
password_ptr = (unsigned char *)SvPVbyte(password, password_len);
|
||||
salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
|
||||
if (salt_len < 8) croak("FATAL: salt_len has to be 8");
|
||||
|
||||
output_len = len;
|
||||
Newz(0, output, output_len, unsigned char);
|
||||
if (!output) croak("FATAL: Newz failed [%ld]", output_len);
|
||||
|
||||
rv = pkcs_5_alg1(password_ptr, (unsigned long)password_len, salt_ptr, iteration_count, id, output, &output_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pkcs_5_alg1 process failed: %s", error_to_string(rv));
|
||||
|
||||
RETVAL = newSVpvn((char *)output, output_len);
|
||||
Safefree(output);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_pkcs_5_alg2(SV * password, SV * salt, int iteration_count, char * hash_name, int len)
|
||||
CODE:
|
||||
{
|
||||
/*
|
||||
int pkcs_5_alg2(const unsigned char *password, unsigned long password_len,
|
||||
const unsigned char *salt, unsigned long salt_len,
|
||||
int iteration_count, int hash_idx,
|
||||
unsigned char *out, unsigned long *outlen)
|
||||
*/
|
||||
int rv, id;
|
||||
unsigned long output_len;
|
||||
unsigned char *output;
|
||||
unsigned char *password_ptr=NULL;
|
||||
STRLEN password_len=0;
|
||||
unsigned char *salt_ptr=NULL;
|
||||
STRLEN salt_len=0;
|
||||
|
||||
id = find_hash(hash_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
|
||||
password_ptr = (unsigned char *)SvPVbyte(password, password_len);
|
||||
salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
|
||||
|
||||
output_len = len;
|
||||
Newz(0, output, output_len, unsigned char);
|
||||
if (!output) croak("FATAL: Newz failed [%ld]", output_len);
|
||||
|
||||
rv = pkcs_5_alg2(password_ptr, (unsigned long)password_len, salt_ptr, (unsigned long)salt_len, iteration_count, id, output, &output_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pkcs_5_alg2 process failed: %s", error_to_string(rv));
|
||||
|
||||
RETVAL = newSVpvn((char *)output, output_len);
|
||||
Safefree(output);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_hkdf_extract(char * hash_name, SV * salt, SV * in)
|
||||
CODE:
|
||||
{
|
||||
/*
|
||||
int hkdf_extract(int hash_idx, const unsigned char *salt, unsigned long saltlen,
|
||||
const unsigned char *in, unsigned long inlen,
|
||||
unsigned char *out, unsigned long *outlen)
|
||||
*/
|
||||
int rv, id;
|
||||
unsigned char output[MAXBLOCKSIZE];
|
||||
unsigned long output_len;
|
||||
unsigned char *in_ptr=NULL;
|
||||
STRLEN in_len=0;
|
||||
unsigned char *salt_ptr=NULL;
|
||||
STRLEN salt_len=0;
|
||||
|
||||
id = find_hash(hash_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
|
||||
in_ptr = (unsigned char *)SvPVbyte(in, in_len);
|
||||
salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
|
||||
|
||||
output_len = sizeof(output);
|
||||
rv = hkdf_extract(id, salt_ptr, (unsigned long)salt_len, in_ptr, (unsigned long)in_len, output, &output_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hkdf_extract process failed: %s", error_to_string(rv));
|
||||
|
||||
RETVAL = newSVpvn((char *)output, output_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_hkdf_expand(char * hash_name, SV * info, SV * in, unsigned long output_len)
|
||||
CODE:
|
||||
{
|
||||
/*
|
||||
int hkdf_expand(int hash_idx, const unsigned char *info, unsigned long infolen,
|
||||
const unsigned char *in, unsigned long inlen,
|
||||
unsigned char *out, unsigned long outlen)
|
||||
*/
|
||||
int rv, id;
|
||||
unsigned char *output;
|
||||
unsigned char *in_ptr=NULL;
|
||||
STRLEN in_len=0;
|
||||
unsigned char *info_ptr=NULL;
|
||||
STRLEN info_len=0;
|
||||
|
||||
id = find_hash(hash_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
|
||||
in_ptr = (unsigned char *)SvPVbyte(in, in_len);
|
||||
info_ptr = (unsigned char *)SvPVbyte(info, info_len);
|
||||
|
||||
Newz(0, output, output_len, unsigned char);
|
||||
if (!output) croak("FATAL: Newz failed [%ld]", output_len);
|
||||
|
||||
rv = hkdf_expand(id, info_ptr, (unsigned long)info_len, in_ptr, (unsigned long)in_len, output, output_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
|
||||
|
||||
RETVAL = newSVpvn((char *)output, output_len);
|
||||
Safefree(output);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_hkdf(char * hash_name, SV * salt, SV * info, SV * in, unsigned long output_len)
|
||||
CODE:
|
||||
{
|
||||
/*
|
||||
int hkdf(int hash_idx, const unsigned char *salt, unsigned long saltlen,
|
||||
const unsigned char *info, unsigned long infolen,
|
||||
const unsigned char *in, unsigned long inlen,
|
||||
unsigned char *out, unsigned long outlen)
|
||||
*/
|
||||
int rv, id;
|
||||
unsigned char *output;
|
||||
unsigned char *in_ptr=NULL;
|
||||
STRLEN in_len=0;
|
||||
unsigned char *info_ptr=NULL;
|
||||
STRLEN info_len=0;
|
||||
unsigned char *salt_ptr=NULL;
|
||||
STRLEN salt_len=0;
|
||||
|
||||
id = find_hash(hash_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
|
||||
in_ptr = (unsigned char *)SvPVbyte(in, in_len);
|
||||
info_ptr = (unsigned char *)SvPVbyte(info, info_len);
|
||||
salt_ptr = (unsigned char *)SvPVbyte(salt, salt_len);
|
||||
|
||||
Newz(0, output, output_len, unsigned char);
|
||||
if (!output) croak("FATAL: Newz failed [%ld]", output_len);
|
||||
|
||||
rv = hkdf(id, salt_ptr, (unsigned long)salt_len, info_ptr, (unsigned long)info_len, in_ptr, (unsigned long)in_len, output, output_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hkdf_expand process failed: %s", error_to_string(rv));
|
||||
|
||||
RETVAL = newSVpvn((char *)output, output_len);
|
||||
Safefree(output);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::BLAKE2b
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::BLAKE2b
|
||||
_new(int size, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct blake2b_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = blake2bmac_init(&RETVAL->state, size, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2b_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::BLAKE2b self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::BLAKE2b
|
||||
clone(Crypt::Mac::BLAKE2b self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct blake2b_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct blake2b_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::BLAKE2b self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = blake2bmac_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2b_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::BLAKE2b self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2bmac_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::BLAKE2b self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2bmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::BLAKE2b self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2bmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::BLAKE2b self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2bmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2bmac_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::BLAKE2s
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::BLAKE2s
|
||||
_new(int size, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct blake2s_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = blake2smac_init(&RETVAL->state, size, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2s_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::BLAKE2s self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::BLAKE2s
|
||||
clone(Crypt::Mac::BLAKE2s self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct blake2s_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct blake2s_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::BLAKE2s self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = blake2smac_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2s_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::BLAKE2s self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2smac_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::BLAKE2s self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2smac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::BLAKE2s self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2smac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::BLAKE2s self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = blake2smac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: blake2smac_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::F9
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::F9
|
||||
_new(char * cipher_name, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct f9_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = f9_init(&RETVAL->state, id, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: f9_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::F9 self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::F9
|
||||
clone(Crypt::Mac::F9 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct f9_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct f9_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::F9 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = f9_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: f9_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::F9 self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = f9_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::F9 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = f9_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::F9 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = f9_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::F9 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = f9_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: f9_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::HMAC
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::HMAC
|
||||
_new(char * hash_name, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
id = find_hash(hash_name);
|
||||
if(id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct hmac_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = hmac_init(&RETVAL->state, id, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hmac_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::HMAC self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::HMAC
|
||||
clone(Crypt::Mac::HMAC self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct hmac_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct hmac_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::HMAC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = hmac_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hmac_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::HMAC self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = hmac_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::HMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = hmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::HMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = hmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::HMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = hmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: hmac_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::OMAC
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::OMAC
|
||||
_new(char * cipher_name, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct omac_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = omac_init(&RETVAL->state, id, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: omac_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::OMAC self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::OMAC
|
||||
clone(Crypt::Mac::OMAC self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct omac_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct omac_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::OMAC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = omac_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: omac_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::OMAC self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = omac_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::OMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = omac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::OMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = omac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::OMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = omac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: omac_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::PMAC
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::PMAC
|
||||
_new(char * cipher_name, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct pmac_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = pmac_init(&RETVAL->state, id, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pmac_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::PMAC self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::PMAC
|
||||
clone(Crypt::Mac::PMAC self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct pmac_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct pmac_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::PMAC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = pmac_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pmac_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::PMAC self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = pmac_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::PMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = pmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::PMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = pmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::PMAC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = pmac_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pmac_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::Pelican
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::Pelican
|
||||
_new(SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct pelican_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = pelican_init(&RETVAL->state, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pelican_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::Pelican self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::Pelican
|
||||
clone(Crypt::Mac::Pelican self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct pelican_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct pelican_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::Pelican self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = pelican_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pelican_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::Pelican self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = 16;
|
||||
rv = pelican_done(&self->state, (unsigned char*)mac);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::Pelican self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = 16;
|
||||
rv = pelican_done(&self->state, mac);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::Pelican self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = 16;
|
||||
rv = pelican_done(&self->state, mac);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::Pelican self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = 16;
|
||||
rv = pelican_done(&self->state, mac);
|
||||
if (rv != CRYPT_OK) croak("FATAL: pelican_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::Poly1305
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::Poly1305
|
||||
_new(SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct poly1305_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = poly1305_init(&RETVAL->state, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: poly1305_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::Poly1305 self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::Poly1305
|
||||
clone(Crypt::Mac::Poly1305 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct poly1305_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct poly1305_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::Poly1305 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = poly1305_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: poly1305_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::Poly1305 self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = poly1305_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::Poly1305 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = poly1305_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::Poly1305 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = poly1305_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::Poly1305 self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = poly1305_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: poly1305_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mac::XCBC
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mac::XCBC
|
||||
_new(char * cipher_name, SV * key)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
int rv;
|
||||
int id;
|
||||
|
||||
id = find_cipher(cipher_name);
|
||||
if(id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct xcbc_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = xcbc_init(&RETVAL->state, id, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: xcbc_init failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mac::XCBC self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Mac::XCBC
|
||||
clone(Crypt::Mac::XCBC self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct xcbc_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct xcbc_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_add_single(Crypt::Mac::XCBC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len>0) {
|
||||
rv = xcbc_process(&self->state, in_data, (unsigned long)in_data_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: xcbc_process failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
|
||||
SV *
|
||||
mac(Crypt::Mac::XCBC self)
|
||||
CODE:
|
||||
{
|
||||
char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = xcbc_done(&self->state, (unsigned char*)mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac, mac_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64mac(Crypt::Mac::XCBC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = xcbc_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
b64umac(Crypt::Mac::XCBC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len;
|
||||
int rv;
|
||||
unsigned long outlen;
|
||||
char mac_base64[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = xcbc_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
|
||||
outlen = sizeof(mac_base64);
|
||||
rv = base64url_encode(mac, mac_len, (unsigned char*)mac_base64, &outlen);
|
||||
if (rv != CRYPT_OK) croak("FATAL: base64url_encode failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn(mac_base64, outlen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
hexmac(Crypt::Mac::XCBC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char mac[MAXBLOCKSIZE];
|
||||
unsigned long mac_len, i;
|
||||
int rv;
|
||||
char mac_hex[MAXBLOCKSIZE*2 + 1];
|
||||
|
||||
mac_len = sizeof(mac);
|
||||
rv = xcbc_done(&self->state, mac, &mac_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: xcbc_done failed: %s", error_to_string(rv));
|
||||
mac_hex[0] = '\0';
|
||||
for(i=0; i<mac_len; i++)
|
||||
sprintf(&mac_hex[2*i], "%02x", mac[i]);
|
||||
RETVAL = newSVpvn(mac_hex, strlen(mac_hex));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,290 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mode::CBC
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mode::CBC
|
||||
_new(char * cipher_name, int padding=1, int rounds=0)
|
||||
CODE:
|
||||
{
|
||||
Newz(0, RETVAL, 1, struct cbc_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->padding_mode = padding;
|
||||
RETVAL->padlen = 0;
|
||||
RETVAL->direction = 0;
|
||||
RETVAL->cipher_rounds = rounds;
|
||||
RETVAL->cipher_id = find_cipher(cipher_name);
|
||||
if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mode::CBC self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
int
|
||||
_get_dir(Crypt::Mode::CBC self)
|
||||
CODE:
|
||||
RETVAL = self->direction;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_start(Crypt::Mode::CBC self, int dir, SV * key, SV * iv)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
STRLEN i_len=0;
|
||||
unsigned char *i=NULL;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
if (!SvPOK(iv)) croak("FATAL: iv must be string/buffer scalar");
|
||||
i = (unsigned char *) SvPVbyte(iv, i_len);
|
||||
if (i_len != (STRLEN)cipher_descriptor[self->cipher_id].block_length) {
|
||||
croak ("FATAL: sizeof(iv) should be equal to blocksize (%d)", cipher_descriptor[self->cipher_id].block_length);
|
||||
}
|
||||
rv = cbc_start(self->cipher_id, i, k, (unsigned long)k_len, self->cipher_rounds, &self->state);
|
||||
if (rv != CRYPT_OK) {
|
||||
croak("FATAL: cbc_start failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
self->direction = dir;
|
||||
self->padlen = 0;
|
||||
}
|
||||
|
||||
SV *
|
||||
_encrypt(Crypt::Mode::CBC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv, has_tmp_block, blen;
|
||||
unsigned long i;
|
||||
|
||||
STRLEN in_data_len, in_data_start;
|
||||
unsigned char *in_data, *out_data, tmp_block[MAXBLOCKSIZE];
|
||||
|
||||
if (self->direction != 1) croak("FATAL: encrypt error, call start_encrypt first (%d)", self->direction);
|
||||
|
||||
blen = (&self->state)->blocklen;
|
||||
in_data_start = 0;
|
||||
has_tmp_block = 0;
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
if(self->padlen > 0) {
|
||||
i = (blen - self->padlen);
|
||||
if (in_data_len >= i) { /* enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, i, unsigned char);
|
||||
in_data_len -= i;
|
||||
in_data_start = i;
|
||||
rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
|
||||
self->padlen = 0;
|
||||
has_tmp_block = 1;
|
||||
}
|
||||
else { /* not enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
|
||||
self->padlen += (int)in_data_len;
|
||||
in_data_len = 0;
|
||||
}
|
||||
} /* padlen > 0 */
|
||||
|
||||
i = (unsigned long)(in_data_len % blen);
|
||||
if (in_data_len>0 && i>0) { /* save tail of data into pad */
|
||||
Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
|
||||
self->padlen = i;
|
||||
in_data_len -= i;
|
||||
}
|
||||
|
||||
if (in_data_len>0) {
|
||||
i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
|
||||
RETVAL = NEWSV(0, i);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, i);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (has_tmp_block) {
|
||||
Copy(tmp_block, out_data, blen, unsigned char);
|
||||
out_data += blen;
|
||||
}
|
||||
rv = cbc_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
|
||||
} /* in_data_len>0 */
|
||||
else if (has_tmp_block) {
|
||||
RETVAL = newSVpvn((char*)tmp_block, blen);
|
||||
}
|
||||
else {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish_enc(Crypt::Mode::CBC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char tmp_block[MAXBLOCKSIZE];
|
||||
int rv, blen, i, j;
|
||||
|
||||
blen = (&self->state)->blocklen;
|
||||
if (self->padlen<0 || self->padlen>=blen) croak("FATAL: invalid padlen");
|
||||
|
||||
if(self->padding_mode == 1) { /* pkcs5|7 padding */
|
||||
i = blen - self->padlen;
|
||||
if (i == 0) i = blen;
|
||||
for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
|
||||
rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else if(self->padding_mode == 2) { /* oneandzeroes padding */
|
||||
self->pad[self->padlen] = 0x80;
|
||||
for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
|
||||
rv = cbc_encrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
if (self->padlen>0) croak("FATAL: cbc_encrypt, input data length not multiple of %d", blen);
|
||||
blen = 0;
|
||||
}
|
||||
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn((char*)tmp_block, blen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_decrypt(Crypt::Mode::CBC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv, has_tmp_block, blen;
|
||||
unsigned long i;
|
||||
STRLEN in_data_len, in_data_start;
|
||||
unsigned char *in_data, *out_data, tmp_block[MAXBLOCKSIZE];
|
||||
|
||||
if (self->direction != -1) croak("FATAL: decrypt error, call start_decryt first (%d)", self->direction);
|
||||
|
||||
blen = (&self->state)->blocklen;
|
||||
in_data_start = 0;
|
||||
has_tmp_block = 0;
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
|
||||
if(self->padlen == blen) {
|
||||
rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
|
||||
self->padlen = 0;
|
||||
has_tmp_block = 1;
|
||||
} /* padlen == blen */
|
||||
else if(self->padlen > 0) {
|
||||
i = (blen - self->padlen); /* remaining bytes in padding buffer */
|
||||
if (in_data_len >= i) { /* enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, i, unsigned char);
|
||||
self->padlen += i;
|
||||
in_data_len -= i;
|
||||
in_data_start = i;
|
||||
if (in_data_len>0 || self->padding_mode == 0) {
|
||||
rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
|
||||
self->padlen = 0;
|
||||
has_tmp_block = 1;
|
||||
}
|
||||
}
|
||||
else { /* not enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
|
||||
self->padlen += (int)in_data_len;
|
||||
in_data_len = 0;
|
||||
}
|
||||
} /* padlen > 0 */
|
||||
|
||||
/* here: a/ padlen==1..16 && in_data_len==0; b/ padlen==0 && in_data_len>0 */
|
||||
if (in_data_len>0) {
|
||||
i = (unsigned long)(in_data_len % blen);
|
||||
if (i>0) { /* save tail of data into pad */
|
||||
Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
|
||||
self->padlen = i;
|
||||
in_data_len -= i;
|
||||
}
|
||||
}
|
||||
|
||||
if (in_data_len>0) {
|
||||
if(self->padlen == 0 && self->padding_mode !=0) {
|
||||
/* in case of padding keep full pad if no more data */
|
||||
Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
|
||||
self->padlen = blen;
|
||||
in_data_len -= blen;
|
||||
}
|
||||
i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
|
||||
if (i == 0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, i);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, i);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
if (has_tmp_block) {
|
||||
Copy(tmp_block, out_data, blen, unsigned char);
|
||||
out_data += blen;
|
||||
}
|
||||
rv = cbc_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
} /* in_data_len>0 */
|
||||
else if (has_tmp_block) {
|
||||
RETVAL = newSVpvn((char*)tmp_block, blen);
|
||||
}
|
||||
else {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish_dec(Crypt::Mode::CBC self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char tmp_block[MAXBLOCKSIZE];
|
||||
unsigned char i;
|
||||
int rv, rv_len, blen;
|
||||
|
||||
rv_len = 0;
|
||||
if (self->padlen > 0) {
|
||||
blen = (&self->state)->blocklen;
|
||||
if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
|
||||
rv = cbc_decrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cbc_decrypt failed: %s", error_to_string(rv));
|
||||
if(self->padding_mode == 0) { /* no padding */
|
||||
rv_len = blen;
|
||||
}
|
||||
else if(self->padding_mode == 1) { /* pkcs5|7 padding */
|
||||
i = tmp_block[blen-1];
|
||||
rv_len = blen - (i>blen ? blen : i);
|
||||
}
|
||||
else if(self->padding_mode == 2) { /* oneandzeroes padding */
|
||||
rv_len = blen;
|
||||
while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
|
||||
if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;
|
||||
if (rv_len<0) rv_len = 0;
|
||||
}
|
||||
}
|
||||
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn((char*)tmp_block, rv_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mode::CFB
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mode::CFB
|
||||
_new(char * cipher_name, int rounds=0)
|
||||
CODE:
|
||||
{
|
||||
Newz(0, RETVAL, 1, struct cfb_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->direction = 0;
|
||||
RETVAL->cipher_rounds = rounds;
|
||||
RETVAL->cipher_id = find_cipher(cipher_name);
|
||||
if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mode::CFB self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
int
|
||||
_get_dir(Crypt::Mode::CFB self)
|
||||
CODE:
|
||||
RETVAL = self->direction;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_start(Crypt::Mode::CFB self, int dir, SV * key, SV * iv)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
STRLEN i_len=0;
|
||||
unsigned char *i=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
if (!SvPOK(iv)) croak("FATAL: iv must be string/buffer scalar");
|
||||
i = (unsigned char *) SvPVbyte(iv, i_len);
|
||||
if (i_len != (STRLEN)cipher_descriptor[self->cipher_id].block_length) {
|
||||
croak ("FATAL: sizeof(iv) should be equal to blocksize (%d)", cipher_descriptor[self->cipher_id].block_length);
|
||||
}
|
||||
|
||||
rv = cfb_start(self->cipher_id, i, k, (int)k_len, self->cipher_rounds, &self->state);
|
||||
if (rv != CRYPT_OK) {
|
||||
croak("FATAL: cfb_start failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
self->direction = dir;
|
||||
}
|
||||
|
||||
SV *
|
||||
_crypt(Crypt::Mode::CFB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (self->direction == 1) {
|
||||
rv = cfb_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cfb_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else if (self->direction == -1) {
|
||||
rv = cfb_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: cfb_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
croak("FATAL: cfb_crypt failed: call start_encrypt or start_decrypt first");
|
||||
}
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish(Crypt::Mode::CFB self)
|
||||
CODE:
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn("", 0);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mode::CTR
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mode::CTR
|
||||
_new(char * cipher_name, int ctr_mode=0, int ctr_width=0, int rounds=0)
|
||||
CODE:
|
||||
{
|
||||
Newz(0, RETVAL, 1, struct ctr_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->direction = 0;
|
||||
RETVAL->cipher_rounds = rounds;
|
||||
RETVAL->cipher_id = find_cipher(cipher_name);
|
||||
if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
if (ctr_mode == 0) RETVAL->ctr_mode_param = CTR_COUNTER_LITTLE_ENDIAN;
|
||||
if (ctr_mode == 1) RETVAL->ctr_mode_param = CTR_COUNTER_BIG_ENDIAN;
|
||||
if (ctr_mode == 2) RETVAL->ctr_mode_param = CTR_COUNTER_LITTLE_ENDIAN|LTC_CTR_RFC3686;
|
||||
if (ctr_mode == 3) RETVAL->ctr_mode_param = CTR_COUNTER_BIG_ENDIAN|LTC_CTR_RFC3686;
|
||||
if (ctr_width > 0 && ctr_width <= cipher_descriptor[RETVAL->cipher_id].block_length) RETVAL->ctr_mode_param |= ctr_width;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mode::CTR self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
int
|
||||
_get_dir(Crypt::Mode::CTR self)
|
||||
CODE:
|
||||
RETVAL = self->direction;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_start(Crypt::Mode::CTR self, int dir, SV * key, SV * iv)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
STRLEN i_len=0;
|
||||
unsigned char *i=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
if (!SvPOK(iv)) croak("FATAL: iv must be string/buffer scalar");
|
||||
i = (unsigned char *) SvPVbyte(iv, i_len);
|
||||
if (i_len != (STRLEN)cipher_descriptor[self->cipher_id].block_length) {
|
||||
croak ("FATAL: sizeof(iv) should be equal to blocksize (%d)", cipher_descriptor[self->cipher_id].block_length);
|
||||
}
|
||||
|
||||
rv = ctr_start(self->cipher_id, i, k, (int)k_len, self->cipher_rounds, self->ctr_mode_param, &self->state);
|
||||
if (rv != CRYPT_OK) {
|
||||
croak("FATAL: ctr_start failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
self->direction = dir;
|
||||
}
|
||||
|
||||
SV *
|
||||
_crypt(Crypt::Mode::CTR self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (self->direction == 1) {
|
||||
rv = ctr_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ctr_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else if (self->direction == -1) {
|
||||
rv = ctr_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ctr_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
croak("FATAL: ctr_crypt failed: call start_encrypt or start_decrypt first");
|
||||
}
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish(Crypt::Mode::CTR self)
|
||||
CODE:
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn("", 0);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,283 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mode::ECB
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mode::ECB
|
||||
_new(char * cipher_name, int padding=1, int rounds=0)
|
||||
CODE:
|
||||
{
|
||||
Newz(0, RETVAL, 1, struct ecb_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->padding_mode = padding;
|
||||
RETVAL->padlen = 0;
|
||||
RETVAL->direction = 0;
|
||||
RETVAL->cipher_rounds = rounds;
|
||||
RETVAL->cipher_id = find_cipher(cipher_name);
|
||||
if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mode::ECB self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
int
|
||||
_get_dir(Crypt::Mode::ECB self)
|
||||
CODE:
|
||||
RETVAL = self->direction;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_start(Crypt::Mode::ECB self, int dir, SV * key)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
rv = ecb_start(self->cipher_id, k, (unsigned long)k_len, self->cipher_rounds, &self->state);
|
||||
if (rv != CRYPT_OK) {
|
||||
croak("FATAL: ecb_start failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
self->direction = dir;
|
||||
self->padlen = 0;
|
||||
}
|
||||
|
||||
SV *
|
||||
_encrypt(Crypt::Mode::ECB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv, has_tmp_block, blen;
|
||||
unsigned long i;
|
||||
|
||||
STRLEN in_data_len, in_data_start;
|
||||
unsigned char *in_data, *out_data, tmp_block[MAXBLOCKSIZE];
|
||||
|
||||
if (self->direction != 1) croak("FATAL: encrypt error, call start_encrypt first (%d)", self->direction);
|
||||
|
||||
blen = (&self->state)->blocklen;
|
||||
in_data_start = 0;
|
||||
has_tmp_block = 0;
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
if(self->padlen > 0) {
|
||||
i = (blen - self->padlen);
|
||||
if (in_data_len >= i) { /* enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, i, unsigned char);
|
||||
in_data_len -= i;
|
||||
in_data_start = i;
|
||||
rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
|
||||
self->padlen = 0;
|
||||
has_tmp_block = 1;
|
||||
}
|
||||
else { /* not enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
|
||||
self->padlen += (int)in_data_len;
|
||||
in_data_len = 0;
|
||||
}
|
||||
} /* padlen > 0 */
|
||||
|
||||
i = (unsigned long)(in_data_len % blen);
|
||||
if (in_data_len>0 && i>0) { /* save tail of data into pad */
|
||||
Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
|
||||
self->padlen = i;
|
||||
in_data_len -= i;
|
||||
}
|
||||
|
||||
if (in_data_len>0) {
|
||||
i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
|
||||
RETVAL = NEWSV(0, i);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, i);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (has_tmp_block) {
|
||||
Copy(tmp_block, out_data, blen, unsigned char);
|
||||
out_data += blen;
|
||||
}
|
||||
rv = ecb_encrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
|
||||
} /* in_data_len>0 */
|
||||
else if (has_tmp_block) {
|
||||
RETVAL = newSVpvn((char*)tmp_block, blen);
|
||||
}
|
||||
else {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish_enc(Crypt::Mode::ECB self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char tmp_block[MAXBLOCKSIZE];
|
||||
int rv, blen, i, j;
|
||||
|
||||
blen = (&self->state)->blocklen;
|
||||
if (self->padlen<0 || self->padlen>=blen) croak("FATAL: invalid padlen");
|
||||
|
||||
if(self->padding_mode == 1) { /* pkcs5|7 padding */
|
||||
i = blen - self->padlen;
|
||||
if (i == 0) i = blen;
|
||||
for(j=self->padlen; j<blen; j++) self->pad[j] = (unsigned char)i;
|
||||
rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else if(self->padding_mode == 2) { /* oneandzeroes padding */
|
||||
self->pad[self->padlen] = 0x80;
|
||||
for(j=self->padlen+1; j<blen; j++) self->pad[j] = 0;
|
||||
rv = ecb_encrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
if (self->padlen>0) croak("FATAL: ecb_encrypt, input data length not multiple of %d", blen);
|
||||
blen = 0;
|
||||
}
|
||||
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn((char*)tmp_block, blen);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_decrypt(Crypt::Mode::ECB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv, has_tmp_block, blen;
|
||||
unsigned long i;
|
||||
STRLEN in_data_len, in_data_start;
|
||||
unsigned char *in_data, *out_data, tmp_block[MAXBLOCKSIZE];
|
||||
|
||||
if (self->direction != -1) croak("FATAL: decrypt error, call start_decryt first (%d)", self->direction);
|
||||
|
||||
blen = (&self->state)->blocklen;
|
||||
in_data_start = 0;
|
||||
has_tmp_block = 0;
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
|
||||
if(self->padlen == blen) {
|
||||
rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
|
||||
self->padlen = 0;
|
||||
has_tmp_block = 1;
|
||||
} /* padlen == blen */
|
||||
else if(self->padlen > 0) {
|
||||
i = (blen - self->padlen); /* remaining bytes in padding buffer */
|
||||
if (in_data_len >= i) { /* enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, i, unsigned char);
|
||||
self->padlen += i;
|
||||
in_data_len -= i;
|
||||
in_data_start = i;
|
||||
if (in_data_len>0 || self->padding_mode == 0) {
|
||||
rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
|
||||
self->padlen = 0;
|
||||
has_tmp_block = 1;
|
||||
}
|
||||
}
|
||||
else { /* not enough data to fill pad */
|
||||
Copy(in_data, self->pad+self->padlen, in_data_len, unsigned char);
|
||||
self->padlen += (int)in_data_len;
|
||||
in_data_len = 0;
|
||||
}
|
||||
} /* padlen > 0 */
|
||||
|
||||
/* here: a/ padlen==1..16 && in_data_len==0; b/ padlen==0 && in_data_len>0 */
|
||||
if (in_data_len>0) {
|
||||
i = (unsigned long)(in_data_len % blen);
|
||||
if (i>0) { /* save tail of data into pad */
|
||||
Copy(in_data+in_data_start+in_data_len-i, self->pad, i, unsigned char);
|
||||
self->padlen = i;
|
||||
in_data_len -= i;
|
||||
}
|
||||
}
|
||||
|
||||
if (in_data_len>0) {
|
||||
if(self->padlen == 0 && self->padding_mode !=0) {
|
||||
/* in case of padding keep full pad if no more data */
|
||||
Copy(in_data+in_data_start+in_data_len-blen, self->pad, blen, unsigned char);
|
||||
self->padlen = blen;
|
||||
in_data_len -= blen;
|
||||
}
|
||||
i = (unsigned long)(has_tmp_block ? in_data_len + blen : in_data_len);
|
||||
if (i == 0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, i);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, i);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
if (has_tmp_block) {
|
||||
Copy(tmp_block, out_data, blen, unsigned char);
|
||||
out_data += blen;
|
||||
}
|
||||
rv = ecb_decrypt(in_data+in_data_start, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
} /* in_data_len>0 */
|
||||
else if (has_tmp_block) {
|
||||
RETVAL = newSVpvn((char*)tmp_block, blen);
|
||||
}
|
||||
else {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish_dec(Crypt::Mode::ECB self)
|
||||
CODE:
|
||||
{
|
||||
unsigned char tmp_block[MAXBLOCKSIZE];
|
||||
unsigned char i;
|
||||
int rv, rv_len, blen;
|
||||
|
||||
rv_len = 0;
|
||||
if (self->padlen > 0) {
|
||||
blen = (&self->state)->blocklen;
|
||||
if (self->padlen != blen) croak("FATAL: cipher text length has to be multiple of %d (%d)", blen, self->padlen);
|
||||
rv = ecb_decrypt(self->pad, tmp_block, blen, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecb_decrypt failed: %s", error_to_string(rv));
|
||||
if(self->padding_mode == 0) { /* no padding */
|
||||
rv_len = blen;
|
||||
}
|
||||
else if(self->padding_mode == 1) { /* pkcs5|7 padding */
|
||||
i = tmp_block[blen-1];
|
||||
rv_len = blen - (i>blen ? blen : i);
|
||||
}
|
||||
else if(self->padding_mode == 2) { /* oneandzeroes padding */
|
||||
rv_len = blen;
|
||||
while ((unsigned char)tmp_block[rv_len-1] == 0x00) rv_len--;
|
||||
if ((unsigned char)tmp_block[rv_len-1] == 0x80) rv_len--;
|
||||
if (rv_len<0) rv_len = 0;
|
||||
}
|
||||
}
|
||||
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn((char*)tmp_block, rv_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Mode::OFB
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
Crypt::Mode::OFB
|
||||
_new(char * cipher_name, int rounds=0)
|
||||
CODE:
|
||||
{
|
||||
Newz(0, RETVAL, 1, struct ofb_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->direction = 0;
|
||||
RETVAL->cipher_rounds = rounds;
|
||||
RETVAL->cipher_id = find_cipher(cipher_name);
|
||||
if(RETVAL->cipher_id==-1) croak("FATAL: find_cipfer failed for '%s'", cipher_name);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Mode::OFB self)
|
||||
CODE:
|
||||
Safefree(self);
|
||||
|
||||
int
|
||||
_get_dir(Crypt::Mode::OFB self)
|
||||
CODE:
|
||||
RETVAL = self->direction;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_start(Crypt::Mode::OFB self, int dir, SV * key, SV * iv)
|
||||
CODE:
|
||||
{
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
STRLEN i_len=0;
|
||||
unsigned char *i=NULL;
|
||||
int rv;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
if (!SvPOK(iv)) croak("FATAL: iv must be string/buffer scalar");
|
||||
i = (unsigned char *) SvPVbyte(iv, i_len);
|
||||
if (i_len != (STRLEN)cipher_descriptor[self->cipher_id].block_length) {
|
||||
croak ("FATAL: sizeof(iv) should be equal to blocksize (%d)", cipher_descriptor[self->cipher_id].block_length);
|
||||
}
|
||||
|
||||
rv = ofb_start(self->cipher_id, i, k, (int)k_len, self->cipher_rounds, &self->state);
|
||||
if (rv != CRYPT_OK) {
|
||||
croak("FATAL: ofb_start failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
self->direction = dir;
|
||||
}
|
||||
|
||||
SV *
|
||||
_crypt(Crypt::Mode::OFB self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
|
||||
if (self->direction == 1) {
|
||||
rv = ofb_encrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ofb_encrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else if (self->direction == -1) {
|
||||
rv = ofb_decrypt(in_data, out_data, (unsigned long)in_data_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ofb_decrypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
croak("FATAL: ofb_crypt failed: call start_encrypt or start_decrypt first");
|
||||
}
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_finish(Crypt::Mode::OFB self)
|
||||
CODE:
|
||||
self->direction = 0;
|
||||
RETVAL = newSVpvn("", 0);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,426 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::PK::DH
|
||||
|
||||
Crypt::PK::DH
|
||||
_new()
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
Newz(0, RETVAL, 1, struct dh_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->key.type = -1;
|
||||
RETVAL->pindex = find_prng("chacha20");
|
||||
if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
|
||||
rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
|
||||
if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
_generate_key(Crypt::PK::DH self, int key_size=256)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
/* gen the key */
|
||||
rv = dh_make_key(&self->pstate, self->pindex, key_size, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_make_key failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_generate_key_ex(Crypt::PK::DH self, SV * g, SV * p)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN p_len = 0;
|
||||
STRLEN g_len = 0;
|
||||
unsigned char *p_ptr=NULL;
|
||||
unsigned char *g_ptr=NULL;
|
||||
|
||||
p_ptr = (unsigned char *)SvPVbyte(p, p_len);
|
||||
g_ptr = (unsigned char *)SvPVbyte(g, g_len);
|
||||
|
||||
/* gen the key */
|
||||
rv = dh_make_key_ex(&self->pstate, self->pindex, (const char *) g_ptr, (const char *) p_ptr, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_make_key_ex failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import(Crypt::PK::DH self, SV * key_data)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
|
||||
rv = dh_import(data, (unsigned long)data_len, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_import failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import_raw(Crypt::PK::DH self, SV * raw_key, int type, char * g, char * p)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(raw_key, data_len);
|
||||
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
|
||||
/* public */
|
||||
if (type == 0) {
|
||||
rv = dh_import_raw(data, (unsigned long)data_len, PK_PUBLIC, g, p, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_import_raw failed: %s", error_to_string(rv));
|
||||
}
|
||||
/* private */
|
||||
else if (type == 1) {
|
||||
rv = dh_import_raw(data, (unsigned long)data_len, PK_PRIVATE, g, p, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_import_raw failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
croak("FATAL: import_raw invalid type '%d'", type);
|
||||
}
|
||||
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
int
|
||||
is_private(Crypt::PK::DH self)
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
RETVAL = (self->key.type == PK_PRIVATE) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
size(Crypt::PK::DH self)
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
RETVAL = dh_get_size(&self->key);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV*
|
||||
key2hash(Crypt::PK::DH self)
|
||||
PREINIT:
|
||||
HV *rv_hash;
|
||||
long siz;
|
||||
char buf[20001];
|
||||
SV **not_used;
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
rv_hash = newHV();
|
||||
/* =====> x */
|
||||
siz = (self->key.x) ? mp_unsigned_bin_size(self->key.x) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'x' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.x, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "x", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "x", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> y */
|
||||
siz = (self->key.y) ? mp_unsigned_bin_size(self->key.y) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'y' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.y, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "y", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "y", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> p */
|
||||
siz = (self->key.prime) ? mp_unsigned_bin_size(self->key.prime) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'p' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.prime, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else {
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
|
||||
/* =====> g */
|
||||
siz = (self->key.base) ? mp_unsigned_bin_size(self->key.base) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'g' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.base, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "g", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else {
|
||||
not_used = hv_store(rv_hash, "g", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> size */
|
||||
not_used = hv_store(rv_hash, "size", 4, newSViv(dh_get_size(&self->key)), 0);
|
||||
/* =====> type */
|
||||
not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
|
||||
if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
|
||||
RETVAL = newRV_noinc((SV*)rv_hash);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV*
|
||||
params2hash(Crypt::PK::DH self)
|
||||
PREINIT:
|
||||
HV *rv_hash;
|
||||
long siz;
|
||||
char buf[20001];
|
||||
SV **not_used;
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
rv_hash = newHV();
|
||||
/* =====> p */
|
||||
siz = (self->key.prime) ? mp_unsigned_bin_size(self->key.prime) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'p' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.prime, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else {
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
|
||||
/* =====> g */
|
||||
siz = (self->key.base) ? mp_unsigned_bin_size(self->key.base) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'g' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.base, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "g", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else {
|
||||
not_used = hv_store(rv_hash, "g", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
|
||||
RETVAL = newRV_noinc((SV*)rv_hash);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
export_key(Crypt::PK::DH self, char * type)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned long int out_len = 4096;
|
||||
unsigned char out[4096];
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(type, "private", 7)) {
|
||||
rv = dh_export(out, &out_len, PK_PRIVATE, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_export(PK_PRIVATE) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public", 6)) {
|
||||
rv = dh_export(out, &out_len, PK_PUBLIC, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_export(PK_PUBLIC) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: export_key_der invalid type '%s'", type);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_encrypt(Crypt::PK::DH self, SV * data, char * hash_name)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned long buffer_len = 1024;
|
||||
unsigned char buffer[1024];
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = dh_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
hash_id, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_encrypt_key failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_decrypt(Crypt::PK::DH self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned long buffer_len = 1024;
|
||||
unsigned char buffer[1024];
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
rv = dh_decrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_decrypt_key failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_sign(Crypt::PK::DH self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned long buffer_len = 1024;
|
||||
unsigned char buffer[1024];
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
rv = dh_sign_hash(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
&self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_sign_hash failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_verify(Crypt::PK::DH self, SV * sig, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv, stat;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char *sig_ptr=NULL;
|
||||
STRLEN sig_len=0;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
sig_ptr = (unsigned char *)SvPVbyte(sig, sig_len);
|
||||
|
||||
RETVAL = 1;
|
||||
rv = dh_verify_hash(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
|
||||
if (rv != CRYPT_OK || stat != 1) RETVAL = 0;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
shared_secret(Crypt::PK::DH self, Crypt::PK::DH pubkey)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned long buffer_len = 1024;
|
||||
unsigned char buffer[1024];
|
||||
|
||||
rv = dh_shared_secret(&self->key, &pubkey->key, buffer, &buffer_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dh_shared_secret failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
export_key_raw(Crypt::PK::DH self, char * type)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned long len, buffer_len = 1024;
|
||||
unsigned char buffer[1024];
|
||||
void *key;
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(type, "private", 7)) {
|
||||
key = self->key.x;
|
||||
}
|
||||
else if (strnEQ(type, "public", 6)) {
|
||||
key = self->key.y;
|
||||
}
|
||||
else {
|
||||
croak("FATAL: export_key_raw: invalid type '%s'", type);
|
||||
}
|
||||
|
||||
len = (unsigned long)mp_unsigned_bin_size(key);
|
||||
if (buffer_len < len) {
|
||||
croak("FATAL: %s", error_to_string(CRYPT_BUFFER_OVERFLOW));
|
||||
}
|
||||
rv = mp_to_unsigned_bin(key, buffer);
|
||||
if (rv != CRYPT_OK) croak("FATAL: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_is_pubkey_valid(Crypt::PK::DH self);
|
||||
CODE:
|
||||
{
|
||||
int rv, i, bits_set = 0;
|
||||
mp_int one, two, p1, *y;
|
||||
mp_digit digit;
|
||||
|
||||
if ((rv = mp_init_multi(&one, &two, &p1, NULL)) != MP_OKAY) {
|
||||
croak("FATAL: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
y = self->key.y;
|
||||
mp_set(&one, 1);
|
||||
mp_set(&two, 2);
|
||||
|
||||
/* p1 = p-1 */
|
||||
if ((rv = mp_sub(self->key.prime, &one, &p1)) != MP_OKAY) {
|
||||
croak("FATAL: %s", error_to_string(rv));
|
||||
}
|
||||
/* valid public key cannot be negative */
|
||||
if (y->sign == MP_NEG) {
|
||||
RETVAL = 0;
|
||||
}
|
||||
/* valid public key != 1 */
|
||||
else if (mp_cmp(y, &one) == MP_EQ) {
|
||||
RETVAL = 0;
|
||||
}
|
||||
/* public key cannot be > p-1 */
|
||||
else if (mp_cmp(y, &p1) == MP_GT) {
|
||||
RETVAL = 0;
|
||||
}
|
||||
/* if base == 2, public must have more than one bit set */
|
||||
else if (mp_cmp(self->key.base, &two) == MP_EQ) {
|
||||
for (i = 0; i < y->used; i++) {
|
||||
digit = y->dp[i];
|
||||
while (digit > ((mp_digit) 0)) {
|
||||
if (digit & ((mp_digit) 1))
|
||||
bits_set++;
|
||||
digit >>= ((mp_digit) 1);
|
||||
}
|
||||
}
|
||||
if (bits_set > 1)
|
||||
RETVAL = 1;
|
||||
else RETVAL = 0;
|
||||
}
|
||||
else RETVAL = 1;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::PK::DH self)
|
||||
CODE:
|
||||
if (self->key.type != -1) { dh_free(&self->key); self->key.type = -1; }
|
||||
Safefree(self);
|
||||
|
||||
|
|
@ -0,0 +1,275 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::PK::DSA
|
||||
|
||||
Crypt::PK::DSA
|
||||
_new()
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
Newz(0, RETVAL, 1, struct dsa_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->key.type = -1;
|
||||
RETVAL->pindex = find_prng("chacha20");
|
||||
if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
|
||||
rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
|
||||
if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
generate_key(Crypt::PK::DSA self, int group_size=30, int modulus_size=256)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
/* gen the key */
|
||||
rv = dsa_make_key(&self->pstate, self->pindex, group_size, modulus_size, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_make_key failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import(Crypt::PK::DSA self, SV * key_data)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
|
||||
rv = dsa_import(data, (unsigned long)data_len, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_import failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import_hex(Crypt::PK::DSA self, char *p, char *q, char *g, char *x, char *y)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
|
||||
rv = dsa_import_radix(16, p, q, g, x, y, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_import_radix failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
int
|
||||
is_private(Crypt::PK::DSA self)
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.qord <= 0) XSRETURN_UNDEF;
|
||||
RETVAL = (self->key.type == PK_PRIVATE) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
size(Crypt::PK::DSA self)
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.qord <= 0) XSRETURN_UNDEF;
|
||||
RETVAL = mp_unsigned_bin_size(self->key.g);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
size_q(Crypt::PK::DSA self)
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.qord <= 0) XSRETURN_UNDEF;
|
||||
RETVAL = self->key.qord;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV*
|
||||
key2hash(Crypt::PK::DSA self)
|
||||
PREINIT:
|
||||
HV *rv_hash;
|
||||
long siz, qsize, psize;
|
||||
char buf[20001];
|
||||
SV **not_used;
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.qord <= 0) XSRETURN_UNDEF;
|
||||
qsize = mp_unsigned_bin_size(self->key.q);
|
||||
psize = mp_unsigned_bin_size(self->key.p);
|
||||
rv_hash = newHV();
|
||||
/* =====> g */
|
||||
siz = (self->key.g) ? mp_unsigned_bin_size(self->key.g) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'g' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.g, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "g", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "g", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> q */
|
||||
siz = (self->key.q) ? mp_unsigned_bin_size(self->key.q) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'q' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.q, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "q", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "q", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> p */
|
||||
siz = (self->key.p) ? mp_unsigned_bin_size(self->key.p) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'p' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.p, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> x */
|
||||
siz = (self->key.x) ? mp_unsigned_bin_size(self->key.x) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'x' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.x, buf, 20000, qsize*2);
|
||||
not_used = hv_store(rv_hash, "x", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "x", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> y */
|
||||
siz = (self->key.y) ? mp_unsigned_bin_size(self->key.y) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'y' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.y, buf, 20000, psize*2);
|
||||
not_used = hv_store(rv_hash, "y", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "y", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> size */
|
||||
not_used = hv_store(rv_hash, "size", 4, newSViv(qsize), 0);
|
||||
/* =====> type */
|
||||
not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
|
||||
if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
|
||||
RETVAL = newRV_noinc((SV*)rv_hash);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
export_key_der(Crypt::PK::DSA self, char * type)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char out[4096];
|
||||
unsigned long int out_len = 4096;
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(type, "private", 7)) {
|
||||
rv = dsa_export(out, &out_len, PK_PRIVATE|PK_STD, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_export(PK_PRIVATE|PK_STD) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public", 6)) {
|
||||
rv = dsa_export(out, &out_len, PK_PUBLIC|PK_STD, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_export(PK_PUBLIC|PK_STD) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: export_key_der invalid type '%s'", type);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_encrypt(Crypt::PK::DSA self, SV * data, char * hash_name)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = dsa_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
hash_id, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_encrypt_key failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_decrypt(Crypt::PK::DSA self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
rv = dsa_decrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_decrypt_key_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_sign(Crypt::PK::DSA self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
rv = dsa_sign_hash(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
&self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: dsa_sign_hash_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_verify(Crypt::PK::DSA self, SV * sig, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv, stat;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char *sig_ptr=NULL;
|
||||
STRLEN sig_len=0;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
sig_ptr = (unsigned char *)SvPVbyte(sig, sig_len);
|
||||
|
||||
RETVAL = 1;
|
||||
rv = dsa_verify_hash(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
|
||||
if (rv != CRYPT_OK || stat != 1) RETVAL = 0;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::PK::DSA self)
|
||||
CODE:
|
||||
if (self->key.type != -1) { dsa_free(&self->key); self->key.type = -1; }
|
||||
Safefree(self);
|
||||
|
||||
|
|
@ -0,0 +1,390 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::PK::ECC
|
||||
|
||||
Crypt::PK::ECC
|
||||
_new()
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
Newz(0, RETVAL, 1, struct ecc_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->pindex = find_prng("chacha20");
|
||||
RETVAL->key.type = -1;
|
||||
ecc_dp_init(&RETVAL->dp);
|
||||
if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
|
||||
rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
|
||||
if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
generate_key(Crypt::PK::ECC self, SV *curve)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
/* setup dp structure */
|
||||
_ecc_set_dp_from_SV(&self->dp, curve); /* croaks on error */
|
||||
/* gen the key */
|
||||
rv = ecc_make_key_ex(&self->pstate, self->pindex, &self->key, &self->dp);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_make_key_ex failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import(Crypt::PK::ECC self, SV * key_data)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
_ecc_free_key(&self->key, &self->dp);
|
||||
rv = ecc_import_full(data, (unsigned long)data_len, &self->key, &self->dp);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_import_full failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import_pkcs8(Crypt::PK::ECC self, SV * key_data)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
_ecc_free_key(&self->key, &self->dp);
|
||||
rv = ecc_import_pkcs8(data, (unsigned long)data_len, NULL, 0, &self->key, &self->dp);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_import_pkcs8 failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
import_key_raw(Crypt::PK::ECC self, SV * key_data, SV * curve)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
_ecc_free_key(&self->key, &self->dp);
|
||||
|
||||
_ecc_set_dp_from_SV(&self->dp, curve); /* croaks on error */
|
||||
|
||||
rv = ecc_import_raw(data, (unsigned long)data_len, &self->key, &self->dp);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_import_raw failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
int
|
||||
is_private(Crypt::PK::ECC self)
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
RETVAL = (self->key.type == PK_PRIVATE) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
size(Crypt::PK::ECC self)
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
RETVAL = ecc_get_size(&self->key);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV*
|
||||
key2hash(Crypt::PK::ECC self)
|
||||
PREINIT:
|
||||
HV *rv_hash;
|
||||
long siz, esize;
|
||||
char buf[20001];
|
||||
SV **not_used;
|
||||
CODE:
|
||||
if (self->key.type == -1) XSRETURN_UNDEF;
|
||||
esize = ecc_get_size(&self->key);
|
||||
rv_hash = newHV();
|
||||
/* =====> k */
|
||||
siz = (self->key.k) ? mp_unsigned_bin_size(self->key.k) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'k' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.k, buf, 20000, esize*2);
|
||||
not_used = hv_store(rv_hash, "k", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "k", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> pub_x */
|
||||
siz = (self->key.pubkey.x) ? mp_unsigned_bin_size(self->key.pubkey.x) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'pub_x' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.pubkey.x, buf, 20000, esize*2);
|
||||
not_used = hv_store(rv_hash, "pub_x", 5, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "pub_x", 5, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> pub_y */
|
||||
siz = (self->key.pubkey.y) ? mp_unsigned_bin_size(self->key.pubkey.y) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'pub_y' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.pubkey.y, buf, 20000, esize*2);
|
||||
not_used = hv_store(rv_hash, "pub_y", 5, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "pub_y", 5, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> curve_... */
|
||||
if (self->key.dp) {
|
||||
not_used = hv_store(rv_hash, "curve_cofactor", 14, newSViv(self->key.dp->cofactor), 0);
|
||||
/* prepend leading zero if we have odd number of hexadecimal digits */
|
||||
strncpy(buf, self->key.dp->prime, 20000); str_add_leading_zero(buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "curve_prime", 11, newSVpv(buf, strlen(buf)), 0);
|
||||
strncpy(buf, self->key.dp->A, 20000); str_add_leading_zero(buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "curve_A", 7, newSVpv(buf, strlen(buf)), 0);
|
||||
strncpy(buf, self->key.dp->B, 20000); str_add_leading_zero(buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "curve_B", 7, newSVpv(buf, strlen(buf)), 0);
|
||||
strncpy(buf, self->key.dp->order, 20000); str_add_leading_zero(buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "curve_order", 11, newSVpv(buf, strlen(buf)), 0);
|
||||
strncpy(buf, self->key.dp->Gx, 20000); str_add_leading_zero(buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "curve_Gx", 8, newSVpv(buf, strlen(buf)), 0);
|
||||
strncpy(buf, self->key.dp->Gy, 20000); str_add_leading_zero(buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "curve_Gy", 8, newSVpv(buf, strlen(buf)), 0);
|
||||
/* OLD approach
|
||||
not_used = hv_store(rv_hash, "curve_prime", 11, newSVpv(self->key.dp->prime, strlen(self->key.dp->prime)), 0);
|
||||
not_used = hv_store(rv_hash, "curve_A", 7, newSVpv(self->key.dp->A, strlen(self->key.dp->A)), 0);
|
||||
not_used = hv_store(rv_hash, "curve_B", 7, newSVpv(self->key.dp->B, strlen(self->key.dp->B)), 0);
|
||||
not_used = hv_store(rv_hash, "curve_order", 11, newSVpv(self->key.dp->order, strlen(self->key.dp->order)), 0);
|
||||
not_used = hv_store(rv_hash, "curve_Gx", 8, newSVpv(self->key.dp->Gx, strlen(self->key.dp->Gx)), 0);
|
||||
not_used = hv_store(rv_hash, "curve_Gy", 8, newSVpv(self->key.dp->Gy, strlen(self->key.dp->Gy)), 0);
|
||||
*/
|
||||
{
|
||||
mp_int p_num;
|
||||
mp_init(&p_num);
|
||||
mp_read_radix(&p_num, self->key.dp->prime, 16);
|
||||
not_used = hv_store(rv_hash, "curve_bytes", 11, newSViv(mp_unsigned_bin_size(&p_num)), 0);
|
||||
not_used = hv_store(rv_hash, "curve_bits", 10, newSViv(mp_count_bits(&p_num)), 0);
|
||||
mp_clear(&p_num);
|
||||
}
|
||||
{
|
||||
unsigned long i;
|
||||
SV *name;
|
||||
char *name_ptr;
|
||||
STRLEN name_len;
|
||||
|
||||
name = newSVpv(self->key.dp->name, strlen(self->key.dp->name));
|
||||
name_ptr = SvPV(name, name_len);
|
||||
for (i=0; i<name_len && name_ptr[i]>0; i++) name_ptr[i] = toLOWER(name_ptr[i]);
|
||||
not_used = hv_store(rv_hash, "curve_name", 10, name, 0);
|
||||
}
|
||||
if (self->key.dp->oid.OIDlen > 0) {
|
||||
unsigned long i;
|
||||
SV *oid = newSVpv("", 0);
|
||||
for(i = 0; i < self->key.dp->oid.OIDlen - 1; i++) sv_catpvf(oid, "%lu.", self->key.dp->oid.OID[i]);
|
||||
sv_catpvf(oid, "%lu", self->key.dp->oid.OID[i]);
|
||||
not_used = hv_store(rv_hash, "curve_oid", 9, oid, 0);
|
||||
}
|
||||
}
|
||||
/* =====> size */
|
||||
not_used = hv_store(rv_hash, "size", 4, newSViv(esize), 0);
|
||||
/* =====> type */
|
||||
not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
|
||||
if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
|
||||
RETVAL = newRV_noinc((SV*)rv_hash);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
export_key_der(Crypt::PK::ECC self, char * type)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char out[4096];
|
||||
unsigned long int out_len = 4096;
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(type, "private_short", 16)) {
|
||||
rv = ecc_export_full(out, &out_len, PK_PRIVATE|PK_CURVEOID, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export(PK_PRIVATE|PK_CURVEOID) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "private", 7)) {
|
||||
rv = ecc_export_full(out, &out_len, PK_PRIVATE, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export(PK_PRIVATE) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public_short", 15)) {
|
||||
rv = ecc_export_full(out, &out_len, PK_PUBLIC|PK_CURVEOID, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export(PK_PUBLIC|PK_CURVEOID) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public", 6)) {
|
||||
rv = ecc_export_full(out, &out_len, PK_PUBLIC, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export(PK_PUBLIC) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: export_key_der invalid type '%s'", type);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
export_key_raw(Crypt::PK::ECC self, char * type)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char out[4096];
|
||||
unsigned long int out_len = sizeof(out);
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(type, "private", 7)) {
|
||||
rv = ecc_export_raw(out, &out_len, PK_PRIVATE, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export_raw(private) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public_compressed", 17)) {
|
||||
rv = ecc_export_raw(out, &out_len, PK_PUBLIC_COMPRESSED, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export_raw(public_compressed) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public", 6)) {
|
||||
rv = ecc_export_raw(out, &out_len, PK_PUBLIC, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_export_raw(public) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: export_key_raw invalid type '%s'", type);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_encrypt(Crypt::PK::ECC self, SV * data, char * hash_name)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = ecc_encrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
hash_id, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_encrypt_key failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_decrypt(Crypt::PK::ECC self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
rv = ecc_decrypt_key(data_ptr, (unsigned long)data_len, buffer, &buffer_len, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_decrypt_key_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_sign(Crypt::PK::ECC self, SV * data)
|
||||
ALIAS:
|
||||
_sign_rfc7518 = 1
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
if (ix == 1) {
|
||||
rv = ecc_sign_hash_rfc7518(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
&self->key);
|
||||
}
|
||||
else {
|
||||
rv = ecc_sign_hash(data_ptr, (unsigned long)data_len, buffer, &buffer_len,
|
||||
&self->pstate, self->pindex,
|
||||
&self->key);
|
||||
}
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_sign_hash_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_verify(Crypt::PK::ECC self, SV * sig, SV * data)
|
||||
ALIAS:
|
||||
_verify_rfc7518 = 1
|
||||
CODE:
|
||||
{
|
||||
int rv, stat;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char *sig_ptr=NULL;
|
||||
STRLEN sig_len=0;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
sig_ptr = (unsigned char *)SvPVbyte(sig, sig_len);
|
||||
|
||||
RETVAL = 1;
|
||||
if (ix == 1) {
|
||||
rv = ecc_verify_hash_rfc7518(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
|
||||
}
|
||||
else {
|
||||
rv = ecc_verify_hash(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, &stat, &self->key);
|
||||
}
|
||||
if (rv != CRYPT_OK || stat != 1) RETVAL = 0;
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
shared_secret(Crypt::PK::ECC self, Crypt::PK::ECC pubkey)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
rv = ecc_shared_secret(&self->key, &pubkey->key, buffer, &buffer_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: ecc_shared_secret failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::PK::ECC self)
|
||||
CODE:
|
||||
_ecc_free_key(&self->key, &self->dp);
|
||||
Safefree(self);
|
||||
|
||||
|
|
@ -0,0 +1,419 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::PK::RSA
|
||||
|
||||
Crypt::PK::RSA
|
||||
_new()
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
Newz(0, RETVAL, 1, struct rsa_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
RETVAL->key.type = -1;
|
||||
RETVAL->pindex = find_prng("chacha20");
|
||||
if(RETVAL->pindex==-1) croak("FATAL: find_prng('chacha20') failed");
|
||||
rv = rng_make_prng(320, RETVAL->pindex, &RETVAL->pstate, NULL); /* 320bits = 40bytes */
|
||||
if (rv != CRYPT_OK) croak("FATAL: rng_make_prng failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
generate_key(Crypt::PK::RSA self, int key_size=256, long key_e=65537)
|
||||
PPCODE:
|
||||
{
|
||||
/* key_size is in octets */
|
||||
int rv;
|
||||
/* gen the key */
|
||||
rv = rsa_make_key(&self->pstate, self->pindex, key_size, key_e, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_make_key failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import(Crypt::PK::RSA self, SV * key_data)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
if (self->key.type != -1) { rsa_free(&self->key); self->key.type = -1; }
|
||||
rv = rsa_import(data, (unsigned long)data_len, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_import failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import_pkcs8(Crypt::PK::RSA self, SV * key_data)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *data=NULL;
|
||||
STRLEN data_len=0;
|
||||
|
||||
data = (unsigned char *)SvPVbyte(key_data, data_len);
|
||||
if (self->key.type != -1) { rsa_free(&self->key); self->key.type = -1; }
|
||||
rv = rsa_import_pkcs8(data, (unsigned long)data_len, NULL, 0, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_import_pkcs8 failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
void
|
||||
_import_hex(Crypt::PK::RSA self, char *N, char *e, char *d=NULL, char *p=NULL, char *q=NULL, char *dP=NULL, char *dQ=NULL, char *qP=NULL)
|
||||
PPCODE:
|
||||
{
|
||||
int rv;
|
||||
if (self->key.type != -1) { rsa_free(&self->key); self->key.type = -1; }
|
||||
rv = rsa_import_radix(16, N, e, d, p, q, dP, dQ, qP, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_import_radix failed: %s", error_to_string(rv));
|
||||
XPUSHs(ST(0)); /* return self */
|
||||
}
|
||||
|
||||
int
|
||||
is_private(Crypt::PK::RSA self)
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.N == NULL) XSRETURN_UNDEF;
|
||||
RETVAL = (self->key.type == PK_PRIVATE) ? 1 : 0;
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
size(Crypt::PK::RSA self)
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.N == NULL) XSRETURN_UNDEF;
|
||||
RETVAL = mp_unsigned_bin_size(self->key.N);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV*
|
||||
key2hash(Crypt::PK::RSA self)
|
||||
PREINIT:
|
||||
HV *rv_hash;
|
||||
long siz, nsize;
|
||||
char buf[20001];
|
||||
SV **not_used;
|
||||
CODE:
|
||||
if (self->key.type == -1 || self->key.N == NULL) XSRETURN_UNDEF;
|
||||
nsize = mp_unsigned_bin_size(self->key.N);
|
||||
rv_hash = newHV();
|
||||
/* =====> e */
|
||||
siz = (self->key.e) ? mp_unsigned_bin_size(self->key.e) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'e' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.e, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "e", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "e", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> d */
|
||||
siz = (self->key.d) ? mp_unsigned_bin_size(self->key.d) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'd' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.d, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "d", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "d", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> N */
|
||||
siz = (self->key.N) ? nsize : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'N' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.N, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "N", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "N", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> q */
|
||||
siz = (self->key.q) ? mp_unsigned_bin_size(self->key.q) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'q' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.q, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "q", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "q", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> p */
|
||||
siz = (self->key.p) ? mp_unsigned_bin_size(self->key.p) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'p' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.p, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "p", 1, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> qP */
|
||||
siz = (self->key.qP) ? mp_unsigned_bin_size(self->key.qP) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'qP' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.qP, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "qP", 2, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "qP", 2, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> dP */
|
||||
siz = (self->key.dP) ? mp_unsigned_bin_size(self->key.dP) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'dP' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.dP, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "dP", 2, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "dP", 2, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> dQ */
|
||||
siz = (self->key.dQ) ? mp_unsigned_bin_size(self->key.dQ) : 0;
|
||||
if (siz>10000) {
|
||||
croak("FATAL: key2hash failed - 'dQ' too big number");
|
||||
}
|
||||
if (siz>0) {
|
||||
mp_tohex_with_leading_zero(self->key.dQ, buf, 20000, 0);
|
||||
not_used = hv_store(rv_hash, "dQ", 2, newSVpv(buf, strlen(buf)), 0);
|
||||
}
|
||||
else{
|
||||
not_used = hv_store(rv_hash, "dQ", 2, newSVpv("", 0), 0);
|
||||
}
|
||||
/* =====> size */
|
||||
not_used = hv_store(rv_hash, "size", 4, newSViv(nsize), 0);
|
||||
/* =====> type */
|
||||
not_used = hv_store(rv_hash, "type", 4, newSViv(self->key.type), 0);
|
||||
if (not_used) not_used = NULL; /* just silence the warning: variable 'not_used' set but not used */
|
||||
RETVAL = newRV_noinc((SV*)rv_hash);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV*
|
||||
export_key_der(Crypt::PK::RSA self, char * type)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char out[4096];
|
||||
unsigned long int out_len = 4096;
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(type, "private", 7)) {
|
||||
rv = rsa_export(out, &out_len, PK_PRIVATE, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_export(PK_PRIVATE) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else if (strnEQ(type, "public", 6)) {
|
||||
rv = rsa_export(out, &out_len, PK_PUBLIC|PK_STD, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_export(PK_PUBLIC|PK_STD) failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)out, out_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: export_key_der invalid type '%s'", type);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_encrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * oaep_lparam)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id;
|
||||
unsigned char *lparam_ptr=NULL;
|
||||
STRLEN lparam_len=0;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(padding, "oaep", 4)) {
|
||||
hash_id = find_hash(oaep_hash);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
|
||||
lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len);
|
||||
rv = rsa_encrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len,
|
||||
&self->pstate, self->pindex,
|
||||
hash_id, LTC_PKCS_1_OAEP, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_encrypt_key_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else if (strnEQ(padding, "v1.5", 4)) {
|
||||
rv = rsa_encrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, NULL, 0,
|
||||
&self->pstate, self->pindex,
|
||||
0, LTC_PKCS_1_V1_5, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_encrypt_key_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else if (strnEQ(padding, "none", 4)) {
|
||||
/* raw RSA */
|
||||
rv = ltc_mp.rsa_me(data_ptr, (unsigned long)data_len, buffer, &buffer_len, PK_PUBLIC, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_me failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: rsa_encrypt invalid padding '%s'", padding);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_decrypt(Crypt::PK::RSA self, SV * data, char * padding, char * oaep_hash, SV * oaep_lparam)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id, stat;
|
||||
unsigned char *lparam_ptr=NULL;
|
||||
STRLEN lparam_len=0;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(padding, "oaep", 4)) {
|
||||
hash_id = find_hash(oaep_hash);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", oaep_hash);
|
||||
lparam_ptr = (unsigned char *)SvPVbyte(oaep_lparam, lparam_len);
|
||||
rv = rsa_decrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, lparam_ptr, (unsigned long)lparam_len,
|
||||
hash_id, LTC_PKCS_1_OAEP, &stat, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_decrypt_key_ex failed: %s", error_to_string(rv));
|
||||
if (stat != 1) croak("FATAL: rsa_decrypt - not valid OAEP packet");
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else if (strnEQ(padding, "v1.5", 4)) {
|
||||
rv = rsa_decrypt_key_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, NULL, 0,
|
||||
0, LTC_PKCS_1_V1_5, &stat, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_decrypt_key_ex failed: %s", error_to_string(rv));
|
||||
if (stat != 1) croak("FATAL: rsa_decrypt - invalid");
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else if (strnEQ(padding, "none", 4)) {
|
||||
/* raw RSA */
|
||||
rv = ltc_mp.rsa_me(data_ptr, (unsigned long)data_len, buffer, &buffer_len, PK_PRIVATE, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_me failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: rsa_encrypt invalid padding '%s'", padding);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
_sign(Crypt::PK::RSA self, SV * data, char * padding, char * hash_name=NULL, unsigned long saltlen=12)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
|
||||
RETVAL = newSVpvn(NULL, 0); /* undef */
|
||||
if (strnEQ(padding, "pss", 3)) {
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = rsa_sign_hash_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, LTC_PKCS_1_PSS,
|
||||
&self->pstate, self->pindex,
|
||||
hash_id, saltlen, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_sign_hash_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else if (strnEQ(padding, "v1.5", 4)) {
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = rsa_sign_hash_ex(data_ptr, (unsigned long)data_len, buffer, &buffer_len, LTC_PKCS_1_V1_5,
|
||||
&self->pstate, self->pindex,
|
||||
hash_id, 0, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_sign_hash_ex failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else if (strnEQ(padding, "none", 4)) {
|
||||
/* raw RSA */
|
||||
rv = ltc_mp.rsa_me(data_ptr, (unsigned long)data_len, buffer, &buffer_len, PK_PRIVATE, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_me failed: %s", error_to_string(rv));
|
||||
RETVAL = newSVpvn((char*)buffer, buffer_len);
|
||||
}
|
||||
else {
|
||||
croak("FATAL: rsa_sign invalid padding '%s'", padding);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
int
|
||||
_verify(Crypt::PK::RSA self, SV * sig, SV * data, char * padding, char * hash_name=NULL, unsigned long saltlen=12)
|
||||
CODE:
|
||||
{
|
||||
int rv, hash_id, stat;
|
||||
unsigned char *data_ptr=NULL;
|
||||
STRLEN data_len=0;
|
||||
unsigned char *sig_ptr=NULL;
|
||||
STRLEN sig_len=0;
|
||||
unsigned char buffer[1024];
|
||||
unsigned long i, buffer_len = 1024;
|
||||
|
||||
data_ptr = (unsigned char *)SvPVbyte(data, data_len);
|
||||
sig_ptr = (unsigned char *)SvPVbyte(sig, sig_len);
|
||||
|
||||
RETVAL = 1;
|
||||
if (strnEQ(padding, "pss", 3)) {
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = rsa_verify_hash_ex(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, LTC_PKCS_1_PSS,
|
||||
hash_id, saltlen, &stat, &self->key);
|
||||
if (rv != CRYPT_OK || stat != 1) RETVAL = 0;
|
||||
}
|
||||
else if (strnEQ(padding, "v1.5", 4)) {
|
||||
hash_id = find_hash(hash_name);
|
||||
if(hash_id==-1) croak("FATAL: find_hash failed for '%s'", hash_name);
|
||||
rv = rsa_verify_hash_ex(sig_ptr, (unsigned long)sig_len, data_ptr, (unsigned long)data_len, LTC_PKCS_1_V1_5,
|
||||
hash_id, 0, &stat, &self->key);
|
||||
if (rv != CRYPT_OK || stat != 1) RETVAL = 0;
|
||||
}
|
||||
else if (strnEQ(padding, "none", 4)) {
|
||||
/* raw RSA */
|
||||
Zero(buffer, buffer_len, unsigned char);
|
||||
rv = ltc_mp.rsa_me(sig_ptr, (unsigned long)sig_len, buffer, &buffer_len, PK_PUBLIC, &self->key);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rsa_me failed: %s", error_to_string(rv));
|
||||
if (data_len <= buffer_len && buffer_len > 0 && data_len > 0) {
|
||||
for (i = 0; i < buffer_len - data_len; i++) if (buffer[i] != 0) RETVAL = 0;
|
||||
if (memNE(data_ptr, buffer + buffer_len - data_len, data_len)) RETVAL = 0;
|
||||
}
|
||||
else {
|
||||
RETVAL = 0;
|
||||
}
|
||||
}
|
||||
else {
|
||||
croak("FATAL: rsa_verify invalid padding '%s'", padding);
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::PK::RSA self)
|
||||
CODE:
|
||||
if (self->key.type != -1) { rsa_free(&self->key); self->key.type = -1; }
|
||||
Safefree(self);
|
||||
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::PRNG
|
||||
|
||||
Crypt::PRNG
|
||||
_new(IV curpid, char * prng_name, SV * entropy=&PL_sv_undef)
|
||||
CODE:
|
||||
{
|
||||
int rv, id;
|
||||
unsigned char *ent=NULL;
|
||||
STRLEN ent_len=0;
|
||||
unsigned char entropy_buf[40];
|
||||
|
||||
Newz(0, RETVAL, 1, struct prng_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
id = find_prng(prng_name);
|
||||
if(id==-1) croak("FATAL: find_prng failed for '%s'", prng_name);
|
||||
RETVAL->id = id;
|
||||
RETVAL->last_pid = curpid;
|
||||
RETVAL->desc = &prng_descriptor[id];
|
||||
|
||||
rv = RETVAL->desc->start(&RETVAL->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_start failed: %s", error_to_string(rv));
|
||||
|
||||
if(SvOK(entropy)) {
|
||||
ent = (unsigned char *) SvPVbyte(entropy, ent_len);
|
||||
rv = RETVAL->desc->add_entropy(ent, (unsigned long)ent_len, &RETVAL->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
if (rng_get_bytes(entropy_buf, 40, NULL) != 40) croak("FATAL: rng_get_bytes failed: %s", error_to_string(rv));
|
||||
rv = RETVAL->desc->add_entropy(entropy_buf, 40, &RETVAL->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
|
||||
}
|
||||
rv = RETVAL->desc->ready(&RETVAL->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_ready failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::PRNG self)
|
||||
CODE:
|
||||
{
|
||||
Safefree(self);
|
||||
}
|
||||
|
||||
void
|
||||
add_entropy(Crypt::PRNG self, SV * entropy=&PL_sv_undef)
|
||||
CODE:
|
||||
{
|
||||
STRLEN in_len=0;
|
||||
unsigned char *in_buffer=NULL;
|
||||
unsigned char entropy_buf[32];
|
||||
int rv;
|
||||
if(SvOK(entropy)) {
|
||||
in_buffer = (unsigned char *) SvPVbyte(entropy, in_len);
|
||||
rv = self->desc->add_entropy(in_buffer, (unsigned long)in_len, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
if (rng_get_bytes(entropy_buf, 32, NULL) != 32) croak("FATAL: rng_get_bytes failed");
|
||||
rv = self->desc->add_entropy(entropy_buf, 32, &self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_add_entropy failed: %s", error_to_string(rv));
|
||||
}
|
||||
rv = self->desc->ready(&self->state);
|
||||
if (rv != CRYPT_OK) croak("FATAL: PRNG_ready failed: %s", error_to_string(rv));
|
||||
}
|
||||
|
||||
SV *
|
||||
_bytes(Crypt::PRNG self, IV curpid, STRLEN output_len)
|
||||
CODE:
|
||||
{
|
||||
int rv_len;
|
||||
unsigned char *rdata;
|
||||
unsigned char entropy_buf[32];
|
||||
|
||||
if (self->last_pid != curpid) {
|
||||
rng_get_bytes(entropy_buf, 32, NULL);
|
||||
self->desc->add_entropy(entropy_buf, 32, &self->state);
|
||||
self->desc->ready(&self->state);
|
||||
self->last_pid = curpid;
|
||||
}
|
||||
|
||||
RETVAL = NEWSV(0, output_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, output_len);
|
||||
rdata = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv_len = (self->desc->read)(rdata, (unsigned long)output_len, &self->state);
|
||||
if ((UV)rv_len != output_len) croak("FATAL: PRNG_read failed");
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
UV
|
||||
_int32(Crypt::PRNG self, IV curpid)
|
||||
CODE:
|
||||
{
|
||||
int i;
|
||||
unsigned char rdata[4];
|
||||
unsigned char entropy_buf[32];
|
||||
|
||||
if (self->last_pid != curpid) {
|
||||
rng_get_bytes(entropy_buf, 32, NULL);
|
||||
self->desc->add_entropy(entropy_buf, 32, &self->state);
|
||||
self->desc->ready(&self->state);
|
||||
self->last_pid = curpid;
|
||||
}
|
||||
|
||||
i = (self->desc->read)(rdata, 4, &self->state);
|
||||
if (i != 4) croak("FATAL: PRNG_read failed");
|
||||
RETVAL = ((UV)(rdata[0])<<24) + ((UV)(rdata[1])<<16) + ((UV)(rdata[2])<<8) + ((UV)(rdata[3]));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
NV
|
||||
_double(Crypt::PRNG self, IV curpid, ...)
|
||||
CODE:
|
||||
{
|
||||
int i;
|
||||
unsigned long a, b; /* 32bit is enough */
|
||||
unsigned char rdata[7]; /* for double we need 53 bits */
|
||||
unsigned char entropy_buf[32];
|
||||
NV limit;
|
||||
|
||||
if (self->last_pid != curpid) {
|
||||
rng_get_bytes(entropy_buf, 32, NULL);
|
||||
self->desc->add_entropy(entropy_buf, 32, &self->state);
|
||||
self->desc->ready(&self->state);
|
||||
self->last_pid = curpid;
|
||||
}
|
||||
|
||||
i = (self->desc->read)(rdata, 7, &self->state);
|
||||
if (i != 7) croak("FATAL: PRNG_read failed");
|
||||
a = (((unsigned long)(rdata[0])<<16) + ((unsigned long)(rdata[1])<<8) + ((unsigned long)(rdata[2]))) & 0x1FFFFF; /* 21 bits */
|
||||
b = ((unsigned long)(rdata[3])<<24) + ((unsigned long)(rdata[4])<<16) + ((unsigned long)(rdata[5])<<8) + ((unsigned long)(rdata[6])); /* 32 bits */
|
||||
RETVAL = ( (NV)a * 4294967296.0 + (NV)b ) / 9007199254740992.0; /* (a * 2^32 + b) / 2^53 */
|
||||
if (items>2 && SvOK(ST(2))) {
|
||||
limit = SvNV(ST(2));
|
||||
if (limit > 0 || limit < 0) RETVAL = RETVAL * limit;
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Stream::ChaCha
|
||||
|
||||
Crypt::Stream::ChaCha
|
||||
_new(SV * key, SV * nonce, UV counter = 0, int rounds = 20)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN iv_len=0, k_len=0;
|
||||
unsigned char *iv=NULL, *k=NULL;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct chacha_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = chacha_setup(&RETVAL->state, k, (unsigned long)k_len, rounds);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha_setup failed: %s", error_to_string(rv));
|
||||
|
||||
if (iv_len == 12) {
|
||||
rv = chacha_ivctr32(&RETVAL->state, iv, (unsigned long)iv_len, (ulong32)counter);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha_ivctr32 failed: %s", error_to_string(rv));
|
||||
}
|
||||
else if (iv_len == 8) {
|
||||
rv = chacha_ivctr64(&RETVAL->state, iv, (unsigned long)iv_len, (ulong64)counter);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha_ivctr64 failed: %s", error_to_string(rv));
|
||||
}
|
||||
else {
|
||||
croak("FATAL: chacha IV length must be 8 or 12 bytes");
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Stream::ChaCha self)
|
||||
CODE:
|
||||
chacha_done(&self->state);
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Stream::ChaCha
|
||||
clone(Crypt::Stream::ChaCha self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct chacha_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct chacha_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
keystream(Crypt::Stream::ChaCha self, STRLEN out_len)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *out_data;
|
||||
|
||||
RETVAL = NEWSV(0, out_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, out_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = chacha_keystream(&self->state, out_data, out_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha_keystream failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
crypt(Crypt::Stream::ChaCha self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = chacha_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: chacha_crypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Stream::RC4
|
||||
|
||||
Crypt::Stream::RC4
|
||||
_new(SV * key)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN k_len=0;
|
||||
unsigned char *k=NULL;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct rc4_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = rc4_stream_setup(&RETVAL->state, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rc4_stream_setup failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Stream::RC4 self)
|
||||
CODE:
|
||||
rc4_stream_done(&self->state);
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Stream::RC4
|
||||
clone(Crypt::Stream::RC4 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct rc4_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct rc4_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
keystream(Crypt::Stream::RC4 self, STRLEN out_len)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *out_data;
|
||||
|
||||
RETVAL = NEWSV(0, out_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, out_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = rc4_stream_keystream(&self->state, out_data, out_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rc4_stream_keystream failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
crypt(Crypt::Stream::RC4 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = rc4_stream_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: rc4_stream_crypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
MODULE = CryptX PACKAGE = Crypt::Stream::Sober128
|
||||
|
||||
Crypt::Stream::Sober128
|
||||
_new(SV * key, SV * nonce)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN iv_len=0, k_len=0;
|
||||
unsigned char *iv=NULL, *k=NULL;
|
||||
|
||||
if (!SvPOK(key)) croak("FATAL: key must be string/buffer scalar");
|
||||
if (!SvPOK(nonce)) croak("FATAL: nonce must be string/buffer scalar");
|
||||
k = (unsigned char *) SvPVbyte(key, k_len);
|
||||
iv = (unsigned char *) SvPVbyte(nonce, iv_len);
|
||||
|
||||
Newz(0, RETVAL, 1, struct sober128_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
|
||||
rv = sober128_stream_setup(&RETVAL->state, k, (unsigned long)k_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sober128_stream_setup failed: %s", error_to_string(rv));
|
||||
|
||||
rv = sober128_stream_setiv(&RETVAL->state, iv, (unsigned long)iv_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sober128_stream_setiv failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
void
|
||||
DESTROY(Crypt::Stream::Sober128 self)
|
||||
CODE:
|
||||
sober128_stream_done(&self->state);
|
||||
Safefree(self);
|
||||
|
||||
Crypt::Stream::Sober128
|
||||
clone(Crypt::Stream::Sober128 self)
|
||||
CODE:
|
||||
Newz(0, RETVAL, 1, struct sober128_struct);
|
||||
if (!RETVAL) croak("FATAL: Newz failed");
|
||||
Copy(&self->state, &RETVAL->state, 1, struct sober128_struct);
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
keystream(Crypt::Stream::Sober128 self, STRLEN out_len)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
unsigned char *out_data;
|
||||
|
||||
RETVAL = NEWSV(0, out_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, out_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = sober128_stream_keystream(&self->state, out_data, out_len);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sober128_stream_keystream failed: %s", error_to_string(rv));
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
||||
SV *
|
||||
crypt(Crypt::Stream::Sober128 self, SV * data)
|
||||
CODE:
|
||||
{
|
||||
int rv;
|
||||
STRLEN in_data_len;
|
||||
unsigned char *in_data, *out_data;
|
||||
|
||||
in_data = (unsigned char *)SvPVbyte(data, in_data_len);
|
||||
if (in_data_len==0) {
|
||||
RETVAL = newSVpvn("", 0);
|
||||
}
|
||||
else {
|
||||
RETVAL = NEWSV(0, in_data_len);
|
||||
SvPOK_only(RETVAL);
|
||||
SvCUR_set(RETVAL, in_data_len);
|
||||
out_data = (unsigned char *)SvPV_nolen(RETVAL);
|
||||
rv = sober128_stream_crypt(&self->state, in_data, (unsigned long)in_data_len, out_data);
|
||||
if (rv != CRYPT_OK) croak("FATAL: sober128_stream_crypt failed: %s", error_to_string(rv));
|
||||
}
|
||||
}
|
||||
OUTPUT:
|
||||
RETVAL
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
package Crypt::AuthEnc;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
sub CLONE_SKIP { 1 } # prevent cloning
|
||||
|
||||
1;
|
||||
|
||||
__END__
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::AuthEnc - [internal only]
|
||||
|
||||
=cut
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
package Crypt::AuthEnc::CCM;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::AuthEnc Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( ccm_encrypt_authenticate ccm_decrypt_verify )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use CryptX;
|
||||
use Crypt::Cipher;
|
||||
|
||||
### the following functions are implemented in XS:
|
||||
# - _memory_encrypt
|
||||
# - _memory_decrypt
|
||||
|
||||
sub ccm_encrypt_authenticate {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $nonce = shift;
|
||||
my $adata = shift;
|
||||
my $tag_len = shift;
|
||||
my $plaintext = shift;
|
||||
return _memory_encrypt(Crypt::Cipher::_trans_cipher_name($cipher_name), $key, $nonce, $adata, $tag_len, $plaintext);
|
||||
}
|
||||
|
||||
sub ccm_decrypt_verify {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $nonce = shift;
|
||||
my $adata = shift;
|
||||
my $ciphertext = shift;
|
||||
my $tag = shift;
|
||||
return _memory_decrypt(Crypt::Cipher::_trans_cipher_name($cipher_name), $key, $nonce, $adata, $ciphertext, $tag);
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::AuthEnc::CCM - Authenticated encryption in CCM mode
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### functional interface
|
||||
use Crypt::AuthEnc::CCM qw(ccm_encrypt_authenticate ccm_decrypt_verify);
|
||||
|
||||
my ($ciphertext, $tag) = ccm_encrypt_authenticate('AES', $key, $nonce, $adata, $tag_len, $plaintext);
|
||||
my $plaintext = ccm_decrypt_verify('AES', $key, $nonce, $adata, $ciphertext, $tag);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
CCM is a encrypt+authenticate mode that is centered around using AES (or any 16-byte cipher) as aprimitive.
|
||||
Unlike EAX and OCB mode, it is only meant for packet mode where the length of the input is known in advance.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::AuthEnc::CCM qw(ccm_encrypt_authenticate ccm_decrypt_verify);
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 ccm_encrypt_authenticate
|
||||
|
||||
my ($ciphertext, $tag) = ccm_encrypt_authenticate($cipher, $key, $nonce, $adata, $tag_len, $plaintext);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher with 16-byte block len
|
||||
# $key ..... key of proper length (e.g. 128/192/256bits for AES)
|
||||
# $nonce ... unique nonce/salt (no need to keep it secret)
|
||||
# $adata ... additional authenticated data
|
||||
# $tag_len . required length of output tag
|
||||
|
||||
CCM parameters should follow L<http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38c.pdf>
|
||||
|
||||
# tag length: 4, 6, 8, 10, 12, 14, 16 (reasonable minimum is 8)
|
||||
# nonce length: 7, 8, 9, 10, 11, 12, 13 (if you are not sure, use 11)
|
||||
# BEWARE nonce length determines max. enc/dec data size: max_data_size = 2^(8*(15-nonce_len))
|
||||
|
||||
=head2 ccm_decrypt_verify
|
||||
|
||||
my $plaintext = ccm_decrypt_verify($cipher, $key, $nonce, $adata, $ciphertext, $tag);
|
||||
|
||||
# on error returns undef
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::AuthEnc::EAX|Crypt::AuthEnc::EAX>, L<Crypt::AuthEnc::GCM|Crypt::AuthEnc::GCM>, L<Crypt::AuthEnc::OCB|Crypt::AuthEnc::OCB>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/CCM_mode|https://en.wikipedia.org/wiki/CCM_mode>
|
||||
|
||||
=back
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
package Crypt::AuthEnc::ChaCha20Poly1305;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::AuthEnc Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( chacha20poly1305_encrypt_authenticate chacha20poly1305_decrypt_verify )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use CryptX;
|
||||
|
||||
sub new { my $class = shift; _new(@_) }
|
||||
|
||||
sub chacha20poly1305_encrypt_authenticate {
|
||||
my $key = shift;
|
||||
my $iv = shift;
|
||||
my $adata = shift;
|
||||
my $plaintext = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::ChaCha20Poly1305->new($key, $iv);
|
||||
$m->adata_add(defined $adata ? $adata : ''); #XXX-TODO if no aad we have to pass empty string
|
||||
my $ct = $m->encrypt_add($plaintext);
|
||||
my $tag = $m->encrypt_done;
|
||||
return ($ct, $tag);
|
||||
}
|
||||
|
||||
sub chacha20poly1305_decrypt_verify {
|
||||
my $key = shift;
|
||||
my $iv = shift;
|
||||
my $adata = shift;
|
||||
my $ciphertext = shift;
|
||||
my $tag = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::ChaCha20Poly1305->new($key, $iv);
|
||||
$m->adata_add(defined $adata ? $adata : ''); #XXX-TODO if no aad we have to pass empty string
|
||||
my $ct = $m->decrypt_add($ciphertext);
|
||||
return $m->decrypt_done($tag) ? $ct : undef;
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::AuthEnc::ChaCha20Poly1305 - Authenticated encryption in ChaCha20Poly1305 mode
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### OO interface
|
||||
use Crypt::AuthEnc::ChaCha20Poly1305;
|
||||
|
||||
# encrypt and authenticate
|
||||
my $ae = Crypt::AuthEnc::ChaCha20Poly1305->new($key, $iv);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$ct = $ae->encrypt_add('data1');
|
||||
$ct = $ae->encrypt_add('data2');
|
||||
$ct = $ae->encrypt_add('data3');
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
# decrypt and verify
|
||||
my $ae = Crypt::AuthEnc::ChaCha20Poly1305->new($key, $iv);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$pt = $ae->decrypt_add('ciphertext1');
|
||||
$pt = $ae->decrypt_add('ciphertext2');
|
||||
$pt = $ae->decrypt_add('ciphertext3');
|
||||
$tag = $ae->decrypt_done();
|
||||
die "decrypt failed" unless $tag eq $expected_tag;
|
||||
|
||||
#or
|
||||
my $result = $ae->decrypt_done($expected_tag) die "decrypt failed";
|
||||
|
||||
### functional interface
|
||||
use Crypt::AuthEnc::ChaCha20Poly1305 qw(chacha20poly1305_encrypt_authenticate chacha20poly1305_decrypt_verify);
|
||||
|
||||
my ($ciphertext, $tag) = chacha20poly1305_encrypt_authenticate($key, $iv, $adata, $plaintext);
|
||||
my $plaintext = chacha20poly1305_decrypt_verify($key, $iv, $adata, $ciphertext, $tag);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides encryption and authentication based on ChaCha20 + Poly1305 as defined in RFC 7539 - L<https://tools.ietf.org/html/rfc7539>
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::AuthEnc::ChaCha20Poly1305 qw(chacha20poly1305_encrypt_authenticate chacha20poly1305_decrypt_verify);
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 chacha20poly1305_encrypt_authenticate
|
||||
|
||||
my ($ciphertext, $tag) = chacha20poly1305_encrypt_authenticate($key, $iv, $adata, $plaintext);
|
||||
|
||||
# $key ..... key of proper length (128 or 256 bits / 16 or 32 bytes)
|
||||
# $iv ...... initialization vector (64 or 96 bits / 8 or 12 bytes)
|
||||
# $adata ... additional authenticated data (optional)
|
||||
|
||||
=head2 chacha20poly1305_decrypt_verify
|
||||
|
||||
my $plaintext = chacha20poly1305_decrypt_verify($key, $iv, $adata, $ciphertext, $tag);
|
||||
|
||||
# on error returns undef
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
my $ae = Crypt::AuthEnc::ChaCha20Poly1305->new($key, $iv);
|
||||
|
||||
# $key ..... encryption key of proper length (128 or 256 bits / 16 or 32 bytes)
|
||||
# $iv ...... initialization vector (64 or 96 bits / 8 or 12 bytes)
|
||||
|
||||
=head2 aad_add
|
||||
|
||||
Can be called before the first C<encrypt_add> or C<decrypt_add>;
|
||||
|
||||
$ae->aad_add($aad_data); #can be called multiple times
|
||||
|
||||
=head2 encrypt_add
|
||||
|
||||
$ciphertext = $ae->encrypt_add($data); #can be called multiple times
|
||||
|
||||
=head2 encrypt_done
|
||||
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
=head2 decrypt_add
|
||||
|
||||
$plaintext = $ae->decrypt_add($ciphertext); #can be called multiple times
|
||||
|
||||
=head2 decrypt_done
|
||||
|
||||
my $result = $ae->decrypt_done($tag); # returns 1 (success) or 0 (failure)
|
||||
#or
|
||||
my $tag = $ae->decrypt_done; # returns $tag value
|
||||
|
||||
=head2 clone
|
||||
|
||||
my $ae_new = $ae->clone;
|
||||
|
||||
=head2 set_iv
|
||||
|
||||
$ae->set_iv($iv);
|
||||
|
||||
=head2 set_iv_rfc7905
|
||||
|
||||
$ae->set_iv_rfc7905($iv, $seqnum);
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::AuthEnc::GCM|Crypt::AuthEnc::GCM>, L<Crypt::AuthEnc::CCM|Crypt::AuthEnc::CCM>, L<Crypt::AuthEnc::EAX|Crypt::AuthEnc::EAX>, L<Crypt::AuthEnc::OCB|Crypt::AuthEnc::OCB>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7539>
|
||||
|
||||
=back
|
||||
|
|
@ -0,0 +1,179 @@
|
|||
package Crypt::AuthEnc::EAX;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::AuthEnc Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( eax_encrypt_authenticate eax_decrypt_verify )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use CryptX;
|
||||
use Crypt::Cipher;
|
||||
|
||||
### the following methods/functions are implemented in XS:
|
||||
# - _new
|
||||
# - DESTROY
|
||||
# - clone
|
||||
# - encrypt_add
|
||||
# - encrypt_done
|
||||
# - decrypt_add
|
||||
# - decrypt_done
|
||||
# - aad_add
|
||||
|
||||
sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
|
||||
|
||||
sub eax_encrypt_authenticate {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $iv = shift;
|
||||
my $adata = shift;
|
||||
my $plaintext = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::EAX->new($cipher_name, $key, $iv);
|
||||
$m->aad_add($adata) if defined $adata;
|
||||
my $ct = $m->encrypt_add($plaintext);
|
||||
my $tag = $m->encrypt_done;
|
||||
return ($ct, $tag);
|
||||
}
|
||||
|
||||
sub eax_decrypt_verify {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $iv = shift;
|
||||
my $adata = shift;
|
||||
my $ciphertext = shift;
|
||||
my $tag = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::EAX->new($cipher_name, $key, $iv);
|
||||
$m->aad_add($adata) if defined $adata;
|
||||
my $ct = $m->decrypt_add($ciphertext);
|
||||
return $m->decrypt_done($tag) ? $ct : undef;
|
||||
}
|
||||
|
||||
sub header_add {
|
||||
# obsolete, only for backwards compatibility
|
||||
shift->aad_add(@_);
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::AuthEnc::EAX - Authenticated encryption in EAX mode
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### OO interface
|
||||
use Crypt::AuthEnc::EAX;
|
||||
|
||||
# encrypt and authenticate
|
||||
my $ae = Crypt::AuthEnc::EAX->new("AES", $key, $iv);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$ct = $ae->encrypt_add('data1');
|
||||
$ct = $ae->encrypt_add('data2');
|
||||
$ct = $ae->encrypt_add('data3');
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
# decrypt and verify
|
||||
my $ae = Crypt::AuthEnc::EAX->new("AES", $key, $iv);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$pt = $ae->decrypt_add('ciphertext1');
|
||||
$pt = $ae->decrypt_add('ciphertext2');
|
||||
$pt = $ae->decrypt_add('ciphertext3');
|
||||
$tag = $ae->decrypt_done();
|
||||
die "decrypt failed" unless $tag eq $expected_tag;
|
||||
|
||||
#or
|
||||
my $result = $ae->decrypt_done($expected_tag) die "decrypt failed";
|
||||
|
||||
### functional interface
|
||||
use Crypt::AuthEnc::EAX qw(eax_encrypt_authenticate eax_decrypt_verify);
|
||||
|
||||
my ($ciphertext, $tag) = eax_encrypt_authenticate('AES', $key, $iv, $adata, $plaintext);
|
||||
my $plaintext = eax_decrypt_verify('AES', $key, $iv, $adata, $ciphertext, $tag);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
EAX is a mode that requires a cipher, CTR and OMAC support and provides encryption and authentication.
|
||||
It is initialized with a random IV that can be shared publicly, additional authenticated data which can
|
||||
be fixed and public, and a random secret symmetric key.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::AuthEnc::EAX qw(eax_encrypt_authenticate eax_decrypt_verify);
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 eax_encrypt_authenticate
|
||||
|
||||
my ($ciphertext, $tag) = eax_encrypt_authenticate($cipher, $key, $iv, $adata, $plaintext);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher with 16-byte block len
|
||||
# $key ..... AES key of proper length (128/192/256bits)
|
||||
# $iv ...... unique initialization vector (no need to keep it secret)
|
||||
# $adata ... additional authenticated data
|
||||
|
||||
=head2 eax_decrypt_verify
|
||||
|
||||
my $plaintext = eax_decrypt_verify($cipher, $key, $iv, $adata, $ciphertext, $tag);
|
||||
|
||||
# on error returns undef
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
my $ae = Crypt::AuthEnc::EAX->new($cipher, $key, $iv);
|
||||
#or
|
||||
my $ae = Crypt::AuthEnc::EAX->new($cipher, $key, $iv, $adata);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher with 16-byte block len
|
||||
# $key ..... AES key of proper length (128/192/256bits)
|
||||
# $iv ...... unique initialization vector (no need to keep it secret)
|
||||
# $adata ... additional authenticated data (optional)
|
||||
|
||||
=head2 aad_add
|
||||
|
||||
$ae->aad_add($adata); #can be called multiple times
|
||||
|
||||
=head2 encrypt_add
|
||||
|
||||
$ciphertext = $ae->encrypt_add($data); #can be called multiple times
|
||||
|
||||
=head2 encrypt_done
|
||||
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
=head2 decrypt_add
|
||||
|
||||
$plaintext = $ae->decrypt_add($ciphertext); #can be called multiple times
|
||||
|
||||
=head2 decrypt_done
|
||||
|
||||
my $result = $ae->decrypt_done($tag); # returns 1 (success) or 0 (failure)
|
||||
#or
|
||||
my $tag = $ae->decrypt_done; # returns $tag value
|
||||
|
||||
=head2 clone
|
||||
|
||||
my $ae_new = $ae->clone;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::AuthEnc::CCM|Crypt::AuthEnc::CCM>, L<Crypt::AuthEnc::GCM|Crypt::AuthEnc::GCM>, L<Crypt::AuthEnc::OCB|Crypt::AuthEnc::OCB>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/EAX_mode|https://en.wikipedia.org/wiki/EAX_mode>
|
||||
|
||||
=back
|
||||
|
|
@ -0,0 +1,179 @@
|
|||
package Crypt::AuthEnc::GCM;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::AuthEnc Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( gcm_encrypt_authenticate gcm_decrypt_verify )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use CryptX;
|
||||
use Crypt::Cipher;
|
||||
|
||||
sub new {
|
||||
my ($class, $cipher, $key, $iv) = @_;
|
||||
my $self = _new(Crypt::Cipher::_trans_cipher_name($cipher), $key);
|
||||
# for backwards compatibility the $iv is optional
|
||||
$self->iv_add($iv) if defined $iv;
|
||||
return $self;
|
||||
}
|
||||
|
||||
sub gcm_encrypt_authenticate {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $iv = shift;
|
||||
my $adata = shift;
|
||||
my $plaintext = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::GCM->new($cipher_name, $key);
|
||||
$m->iv_add($iv);
|
||||
$m->adata_add(defined $adata ? $adata : ''); #XXX-TODO if no aad we have to pass empty string
|
||||
my $ct = $m->encrypt_add($plaintext);
|
||||
my $tag = $m->encrypt_done;
|
||||
return ($ct, $tag);
|
||||
}
|
||||
|
||||
sub gcm_decrypt_verify {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $iv = shift;
|
||||
my $adata = shift;
|
||||
my $ciphertext = shift;
|
||||
my $tag = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::GCM->new($cipher_name, $key);
|
||||
$m->iv_add($iv);
|
||||
$m->adata_add(defined $adata ? $adata : ''); #XXX-TODO if no aad we have to pass empty string
|
||||
my $ct = $m->decrypt_add($ciphertext);
|
||||
return $m->decrypt_done($tag) ? $ct : undef;
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::AuthEnc::GCM - Authenticated encryption in GCM mode
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### OO interface
|
||||
use Crypt::AuthEnc::GCM;
|
||||
|
||||
# encrypt and authenticate
|
||||
my $ae = Crypt::AuthEnc::GCM->new("AES", $key, $iv);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$ct = $ae->encrypt_add('data1');
|
||||
$ct = $ae->encrypt_add('data2');
|
||||
$ct = $ae->encrypt_add('data3');
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
# decrypt and verify
|
||||
my $ae = Crypt::AuthEnc::GCM->new("AES", $key, $iv);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$pt = $ae->decrypt_add('ciphertext1');
|
||||
$pt = $ae->decrypt_add('ciphertext2');
|
||||
$pt = $ae->decrypt_add('ciphertext3');
|
||||
$tag = $ae->decrypt_done();
|
||||
die "decrypt failed" unless $tag eq $expected_tag;
|
||||
|
||||
#or
|
||||
my $result = $ae->decrypt_done($expected_tag) die "decrypt failed";
|
||||
|
||||
### functional interface
|
||||
use Crypt::AuthEnc::GCM qw(gcm_encrypt_authenticate gcm_decrypt_verify);
|
||||
|
||||
my ($ciphertext, $tag) = gcm_encrypt_authenticate('AES', $key, $iv, $adata, $plaintext);
|
||||
my $plaintext = gcm_decrypt_verify('AES', $key, $iv, $adata, $ciphertext, $tag);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Galois/Counter Mode (GCM) - provides encryption and authentication.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::AuthEnc::GCM qw(gcm_encrypt_authenticate gcm_decrypt_verify);
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 gcm_encrypt_authenticate
|
||||
|
||||
my ($ciphertext, $tag) = gcm_encrypt_authenticate($cipher, $key, $iv, $adata, $plaintext);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher with 16-byte block len
|
||||
# $key ..... AES key of proper length (128/192/256bits)
|
||||
# $iv ...... initialization vector
|
||||
# $adata ... additional authenticated data
|
||||
|
||||
=head2 gcm_decrypt_verify
|
||||
|
||||
my $plaintext = gcm_decrypt_verify($cipher, $key, $iv, $adata, $ciphertext, $tag);
|
||||
|
||||
# on error returns undef
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
my $ae = Crypt::AuthEnc::GCM->new($cipher, $key);
|
||||
#or
|
||||
my $ae = Crypt::AuthEnc::GCM->new($cipher, $key, $iv);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher
|
||||
# $key ..... encryption key of proper length
|
||||
# $iv ...... initialization vector (optional, you can set it later via iv_add method)
|
||||
|
||||
=head2 iv_add
|
||||
|
||||
$ae->iv_add($iv_data); #can be called multiple times
|
||||
|
||||
=head2 aad_add
|
||||
|
||||
Can be called B<after> all C<iv_add> calls but before the first C<encrypt_add> or C<decrypt_add>;
|
||||
|
||||
$ae->aad_add($aad_data); #can be called multiple times
|
||||
|
||||
=head2 encrypt_add
|
||||
|
||||
$ciphertext = $ae->encrypt_add($data); #can be called multiple times
|
||||
|
||||
=head2 encrypt_done
|
||||
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
=head2 decrypt_add
|
||||
|
||||
$plaintext = $ae->decrypt_add($ciphertext); #can be called multiple times
|
||||
|
||||
=head2 decrypt_done
|
||||
|
||||
my $result = $ae->decrypt_done($tag); # returns 1 (success) or 0 (failure)
|
||||
#or
|
||||
my $tag = $ae->decrypt_done; # returns $tag value
|
||||
|
||||
=head2 reset
|
||||
|
||||
$ae->reset;
|
||||
|
||||
=head2 clone
|
||||
|
||||
my $ae_new = $ae->clone;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::AuthEnc::CCM|Crypt::AuthEnc::CCM>, L<Crypt::AuthEnc::EAX|Crypt::AuthEnc::EAX>, L<Crypt::AuthEnc::OCB|Crypt::AuthEnc::OCB>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/Galois/Counter_Mode>
|
||||
|
||||
=back
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
package Crypt::AuthEnc::OCB;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::AuthEnc Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( ocb_encrypt_authenticate ocb_decrypt_verify )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use CryptX;
|
||||
use Crypt::Cipher;
|
||||
|
||||
sub new { my $class = shift; _new(Crypt::Cipher::_trans_cipher_name(shift), @_) }
|
||||
|
||||
sub ocb_encrypt_authenticate {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $nonce = shift;
|
||||
my $adata = shift;
|
||||
my $plaintext = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::OCB->new($cipher_name, $key, $nonce);
|
||||
$m->aad_add($adata) if defined $adata;
|
||||
my $ct = $m->encrypt_last($plaintext);
|
||||
my $tag = $m->encrypt_done;
|
||||
return ($ct, $tag);
|
||||
}
|
||||
|
||||
sub ocb_decrypt_verify {
|
||||
my $cipher_name = shift;
|
||||
my $key = shift;
|
||||
my $nonce = shift;
|
||||
my $adata = shift;
|
||||
my $ciphertext = shift;
|
||||
my $tag = shift;
|
||||
|
||||
my $m = Crypt::AuthEnc::OCB->new($cipher_name, $key, $nonce);
|
||||
$m->aad_add($adata) if defined $adata;
|
||||
my $ct = $m->decrypt_last($ciphertext);
|
||||
return $m->decrypt_done($tag) ? $ct : undef;
|
||||
}
|
||||
|
||||
sub adata_add {
|
||||
# obsolete, only for backwards compatibility
|
||||
shift->aad_add(@_);
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::AuthEnc::OCB - Authenticated encryption in OCBv3 mode
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### OO interface
|
||||
use Crypt::AuthEnc::OCB;
|
||||
|
||||
# encrypt and authenticate
|
||||
my $ae = Crypt::AuthEnc::OCB->new("AES", $key, $nonce);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$ct = $ae->encrypt_add('data1');
|
||||
$ct = $ae->encrypt_add('data2');
|
||||
$ct = $ae->encrypt_add('data3');
|
||||
$ct = $ae->encrypt_last('rest of data');
|
||||
($ct,$tag) = $ae->encrypt_done();
|
||||
|
||||
# decrypt and verify
|
||||
my $ae = Crypt::AuthEnc::OCB->new("AES", $key, $nonce);
|
||||
$ae->aad_add('additional_authenticated_data1');
|
||||
$ae->aad_add('additional_authenticated_data2');
|
||||
$pt = $ae->decrypt_add('ciphertext1');
|
||||
$pt = $ae->decrypt_add('ciphertext2');
|
||||
$pt = $ae->decrypt_add('ciphertext3');
|
||||
$pt = $ae->decrypt_last('rest of data');
|
||||
($pt,$tag) = $ae->decrypt_done();
|
||||
|
||||
### functional interface
|
||||
use Crypt::AuthEnc::OCB qw(ocb_encrypt_authenticate ocb_decrypt_verify);
|
||||
|
||||
my ($ciphertext, $tag) = ocb_encrypt_authenticate('AES', $key, $nonce, $adata, $plaintext);
|
||||
my $plaintext = ocb_decrypt_verify('AES', $key, $nonce, $adata, $ciphertext, $tag);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements OCB version 3 according http://datatracker.ietf.org/doc/draft-irtf-cfrg-ocb/
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::AuthEnc::OCB qw(ocb_encrypt_authenticate ocb_decrypt_verify);
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 ocb_encrypt_authenticate
|
||||
|
||||
my ($ciphertext, $tag) = ocb_encrypt_authenticate($cipher, $key, $nonce, $adata, $plaintext);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher with 16-byte block len
|
||||
# $key ..... AES key of proper length (128/192/256bits)
|
||||
# $nonce ... unique nonce/salt (no need to keep it secret)
|
||||
# $adata ... additional authenticated data
|
||||
|
||||
=head2 ocb_decrypt_verify
|
||||
|
||||
my $plaintext = ocb_decrypt_verify($cipher, $key, $nonce, $adata, $ciphertext, $tag);
|
||||
|
||||
# on error returns undef
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
my $ae = Crypt::AuthEnc::OCB->new($cipher, $key, $nonce);
|
||||
|
||||
# $cipher .. 'AES' or name of any other cipher with 16-byte block len
|
||||
# $key ..... AES key of proper length (128/192/256bits)
|
||||
# $nonce ... unique nonce/salt (no need to keep it secret)
|
||||
|
||||
=head2 aad_add
|
||||
|
||||
$ae->aad_add($adata); #can be called multiple times
|
||||
|
||||
=head2 encrypt_add
|
||||
|
||||
$ciphertext = $ae->encrypt_add($data); #can be called multiple times
|
||||
|
||||
#BEWARE: size of $data has to be multiple of blocklen (16 for AES)
|
||||
|
||||
=head2 encrypt_last
|
||||
|
||||
$ciphertext = $ae->encrypt_last($data);
|
||||
|
||||
=head2 encrypt_done
|
||||
|
||||
$tag = $ae->encrypt_done();
|
||||
|
||||
=head2 decrypt_add
|
||||
|
||||
$plaintext = $ae->decrypt_add($ciphertext); #can be called multiple times
|
||||
|
||||
#BEWARE: size of $ciphertext has to be multiple of blocklen (16 for AES)
|
||||
|
||||
=head2 encrypt_last
|
||||
|
||||
$plaintext = $ae->decrypt_last($data);
|
||||
|
||||
=head2 decrypt_done
|
||||
|
||||
my $result = $ae->decrypt_done($tag); # returns 1 (success) or 0 (failure)
|
||||
#or
|
||||
my $tag = $ae->decrypt_done; # returns $tag value
|
||||
|
||||
=head2 clone
|
||||
|
||||
my $ae_new = $ae->clone;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::AuthEnc::CCM|Crypt::AuthEnc::CCM>, L<Crypt::AuthEnc::GCM|Crypt::AuthEnc::GCM>, L<Crypt::AuthEnc::EAX|Crypt::AuthEnc::EAX>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/OCB_mode|https://en.wikipedia.org/wiki/OCB_mode>
|
||||
|
||||
=back
|
||||
|
|
@ -0,0 +1,197 @@
|
|||
package Crypt::Checksum;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
|
||||
our %EXPORT_TAGS = ( all => [qw/
|
||||
adler32_data adler32_data_hex adler32_data_int adler32_file adler32_file_hex adler32_file_int
|
||||
crc32_data crc32_data_hex crc32_data_int crc32_file crc32_file_hex crc32_file_int
|
||||
/] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
use Crypt::Checksum::Adler32;
|
||||
use Crypt::Checksum::CRC32;
|
||||
|
||||
sub adler32_data { Crypt::Checksum::Adler32->new->add(@_)->digest }
|
||||
sub adler32_data_hex { Crypt::Checksum::Adler32->new->add(@_)->hexdigest }
|
||||
sub adler32_data_int { unpack("N", Crypt::Checksum::Adler32->new->add(@_)->digest) }
|
||||
sub adler32_file { Crypt::Checksum::Adler32->new->addfile(@_)->digest }
|
||||
sub adler32_file_hex { Crypt::Checksum::Adler32->new->addfile(@_)->hexdigest }
|
||||
sub adler32_file_int { unpack("N", Crypt::Checksum::Adler32->new->addfile(@_)->digest) }
|
||||
sub crc32_data { Crypt::Checksum::CRC32->new->add(@_)->digest }
|
||||
sub crc32_data_hex { Crypt::Checksum::CRC32->new->add(@_)->hexdigest }
|
||||
sub crc32_data_int { unpack("N", Crypt::Checksum::CRC32->new->add(@_)->digest) }
|
||||
sub crc32_file { Crypt::Checksum::CRC32->new->addfile(@_)->digest }
|
||||
sub crc32_file_hex { Crypt::Checksum::CRC32->new->addfile(@_)->hexdigest }
|
||||
sub crc32_file_int { unpack("N", Crypt::Checksum::CRC32->new->addfile(@_)->digest) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Checksum - functional interface to CRC32 and Adler32 checksums
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
use Crypt::Checksum ':all';
|
||||
|
||||
# calculate Adler32 checksum from string/buffer
|
||||
$checksum_raw = adler32_data($data);
|
||||
$checksum_hex = adler32_data_hex($data);
|
||||
|
||||
# calculate Adler32 checksum from file
|
||||
$checksum_raw = adler32_file('filename.dat');
|
||||
$checksum_hex = adler32_file_hex('filename.dat');
|
||||
|
||||
# calculate Adler32 checksum from filehandle
|
||||
$checksum_raw = adler32_file(*FILEHANDLE);
|
||||
$checksum_hex = adler32_file_hex(*FILEHANDLE);
|
||||
|
||||
# calculate CRC32 checksum from string/buffer
|
||||
$checksum_raw = crc32_data($data);
|
||||
$checksum_hex = crc32_data_hex($data);
|
||||
|
||||
# calculate CRC32 checksum from file
|
||||
$checksum_raw = crc32_file('filename.dat');
|
||||
$checksum_hex = crc32_file_hex('filename.dat');
|
||||
|
||||
# calculate CRC32 checksum from filehandle
|
||||
$checksum_raw = crc32_file(*FILEHANDLE);
|
||||
$checksum_hex = crc32_file_hex(*FILEHANDLE);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Calculating CRC32 and Adler32 checksums (functional interface);
|
||||
|
||||
I<Since: CryptX-0.032>
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Checksum qw( adler32_data adler32_data_hex adler32_file adler32_file_hex
|
||||
crc32_data crc32_data_hex crc32_file crc32_file_hex );
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Checksum ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 adler32_data
|
||||
|
||||
Returns checksum as raw octects.
|
||||
|
||||
$checksum_raw = adler32_data('data string');
|
||||
#or
|
||||
$checksum_raw = adler32_data('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 adler32_data_hex
|
||||
|
||||
Returns checksum as a hexadecimal string.
|
||||
|
||||
$checksum_hex = adler32_data_hex('data string');
|
||||
#or
|
||||
$checksum_hex = adler32_data_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 adler32_data_int
|
||||
|
||||
Returns checksum as unsingned 32bit integer.
|
||||
|
||||
$checksum_hex = adler32_data_int('data string');
|
||||
#or
|
||||
$checksum_hex = adler32_data_int('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 adler32_file
|
||||
|
||||
Returns checksum as raw octects.
|
||||
|
||||
$checksum_raw = adler32_file('filename.dat');
|
||||
#or
|
||||
$checksum_raw = adler32_file(*FILEHANDLE);
|
||||
|
||||
=head2 adler32_file_hex
|
||||
|
||||
Returns checksum as a hexadecimal string.
|
||||
|
||||
$checksum_hex = adler32_file_hex('filename.dat');
|
||||
#or
|
||||
$checksum_hex = adler32_file_hex(*FILEHANDLE);
|
||||
|
||||
=head2 adler32_file_int
|
||||
|
||||
Returns checksum as unsingned 32bit integer.
|
||||
|
||||
$checksum_hex = adler32_file_int('data string');
|
||||
#or
|
||||
$checksum_hex = adler32_file_int('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 crc32_data
|
||||
|
||||
Returns checksum as raw octects.
|
||||
|
||||
$checksum_raw = crc32_data('data string');
|
||||
#or
|
||||
$checksum_raw = crc32_data('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 crc32_data_hex
|
||||
|
||||
Returns checksum as a hexadecimal string.
|
||||
|
||||
$checksum_hex = crc32_data_hex('data string');
|
||||
#or
|
||||
$checksum_hex = crc32_data_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 crc32_data_int
|
||||
|
||||
Returns checksum as unsingned 32bit integer.
|
||||
|
||||
$checksum_hex = crc32_data_int('data string');
|
||||
#or
|
||||
$checksum_hex = crc32_data_int('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 crc32_file
|
||||
|
||||
Returns checksum as raw octects.
|
||||
|
||||
$checksum_raw = crc32_file('filename.dat');
|
||||
#or
|
||||
$checksum_raw = crc32_file(*FILEHANDLE);
|
||||
|
||||
=head2 crc32_file_hex
|
||||
|
||||
Returns checksum as a hexadecimal string.
|
||||
|
||||
$checksum_hex = crc32_file_hex('filename.dat');
|
||||
#or
|
||||
$checksum_hex = crc32_file_hex(*FILEHANDLE);
|
||||
|
||||
=head2 crc32_file_int
|
||||
|
||||
Returns checksum as unsingned 32bit integer.
|
||||
|
||||
$checksum_hex = crc32_file_int('data string');
|
||||
#or
|
||||
$checksum_hex = crc32_file_int('any data', 'more data', 'even more data');
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Checksum::Adler32>, L<Crypt::Checksum::CRC32>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/Adler-32>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/Cyclic_redundancy_check>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Checksum::Adler32;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
use Carp;
|
||||
use CryptX;
|
||||
|
||||
sub addfile {
|
||||
my ($self, $file) = @_;
|
||||
|
||||
my $handle;
|
||||
if (ref(\$file) eq 'SCALAR') { #filename
|
||||
open($handle, "<", $file) || croak "FATAL: cannot open '$file': $!";
|
||||
binmode($handle);
|
||||
}
|
||||
else { #handle
|
||||
$handle = $file
|
||||
}
|
||||
croak "FATAL: invalid handle" unless defined $handle;
|
||||
|
||||
my $n;
|
||||
my $buf = "";
|
||||
while (($n = read($handle, $buf, 32*1024))) {
|
||||
$self->add($buf)
|
||||
}
|
||||
croak "FATAL: read failed: $!" unless defined $n;
|
||||
|
||||
return $self;
|
||||
}
|
||||
|
||||
sub CLONE_SKIP { 1 } # prevent cloning
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Checksum::Adler32 - Compute Adler32 checksum
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
use Crypt::Checksum::Adler32;
|
||||
|
||||
$d = Crypt::Checksum::Adler32->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$checksum_raw = $d->digest; # raw bytes
|
||||
$checksum_hex = $d->hexdigest; # hexadecimal form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Calculating Adler32 checksums (OO interface);
|
||||
|
||||
I<Since: CryptX-0.032>
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
Constructor, returns a reference to the checksum object.
|
||||
|
||||
$d = Crypt::Checksum::Adler32->new;
|
||||
|
||||
=head2 clone
|
||||
|
||||
Creates a copy of the checksum object state and returns a reference to the copy.
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
Reinitialize the checksum object state and returns a reference to the checksum object.
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
All arguments are appended to the message we calculate checksum for.
|
||||
The return value is the checksum object itself.
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
The content of the file (or filehandle) is appended to the message we calculate checksum for.
|
||||
The return value is the checksum object itself.
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 digest
|
||||
|
||||
Returns the binary checksum (raw bytes).
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
Returns the checksum encoded as a hexadecimal string.
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Checksum>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/Adler-32>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Checksum::CRC32;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
use Carp;
|
||||
use CryptX;
|
||||
|
||||
sub addfile {
|
||||
my ($self, $file) = @_;
|
||||
|
||||
my $handle;
|
||||
if (ref(\$file) eq 'SCALAR') { #filename
|
||||
open($handle, "<", $file) || croak "FATAL: cannot open '$file': $!";
|
||||
binmode($handle);
|
||||
}
|
||||
else { #handle
|
||||
$handle = $file
|
||||
}
|
||||
croak "FATAL: invalid handle" unless defined $handle;
|
||||
|
||||
my $n;
|
||||
my $buf = "";
|
||||
while (($n = read($handle, $buf, 32*1024))) {
|
||||
$self->add($buf)
|
||||
}
|
||||
croak "FATAL: read failed: $!" unless defined $n;
|
||||
|
||||
return $self;
|
||||
}
|
||||
|
||||
sub CLONE_SKIP { 1 } # prevent cloning
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Checksum::CRC32 - Compute CRC32 checksum
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
use Crypt::Checksum::CRC32;
|
||||
|
||||
$d = Crypt::Checksum::CRC32->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$checksum_raw = $d->digest; # raw bytes
|
||||
$checksum_hex = $d->hexdigest; # hexadecimal form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Calculating CRC32 checksums (OO interface);
|
||||
|
||||
I<Since: CryptX-0.032>
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
Constructor, returns a reference to the checksum object.
|
||||
|
||||
$d = Crypt::Checksum::CRC32->new;
|
||||
|
||||
=head2 clone
|
||||
|
||||
Creates a copy of the checksum object state and returns a reference to the copy.
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
Reinitialize the checksum object state and returns a reference to the checksum object.
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
All arguments are appended to the message we calculate checksum for.
|
||||
The return value is the checksum object itself.
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
The content of the file (or filehandle) is appended to the message we calculate checksum for.
|
||||
The return value is the checksum object itself.
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 digest
|
||||
|
||||
Returns the binary checksum (raw bytes).
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
Returns the checksum encoded as a hexadecimal string.
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Checksum>
|
||||
|
||||
=item * L<https://en.wikipedia.org/wiki/Cyclic_redundancy_check>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
|
@ -0,0 +1,217 @@
|
|||
package Crypt::Cipher;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
use CryptX;
|
||||
|
||||
### the following methods/functions are implemented in XS:
|
||||
# - _new
|
||||
# - DESTROY
|
||||
# - _keysize
|
||||
# - _max_keysize
|
||||
# - _min_keysize
|
||||
# - _blocksize
|
||||
# - _default_rounds
|
||||
# - encrypt
|
||||
# - decrypt
|
||||
#functions, not methods:
|
||||
# - _block_length_by_name
|
||||
# - _min_key_length_by_name
|
||||
# - _max_key_length_by_name
|
||||
# - _default_rounds_by_name
|
||||
|
||||
sub _trans_cipher_name {
|
||||
my $name = shift;
|
||||
my %trans = (
|
||||
DES_EDE => '3des',
|
||||
SAFERP => 'safer+',
|
||||
SAFER_K128 => 'safer-k128',
|
||||
SAFER_K64 => 'safer-k64',
|
||||
SAFER_SK128 => 'safer-sk128',
|
||||
SAFER_SK64 => 'safer-sk64',
|
||||
);
|
||||
$name =~ s/^Crypt::Cipher:://;
|
||||
return $trans{uc($name)} if defined $trans{uc($name)};
|
||||
return lc($name);
|
||||
}
|
||||
|
||||
### METHODS
|
||||
|
||||
sub new {
|
||||
my $pkg = shift;
|
||||
my $cipher_name = $pkg eq __PACKAGE__ ? _trans_cipher_name(shift) : _trans_cipher_name($pkg);
|
||||
return _new($cipher_name, @_);
|
||||
}
|
||||
|
||||
sub blocksize {
|
||||
my $self = shift;
|
||||
return $self->_blocksize if ref($self);
|
||||
$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
|
||||
return _block_length_by_name(_trans_cipher_name($self));
|
||||
}
|
||||
|
||||
sub keysize {
|
||||
max_keysize(@_);
|
||||
}
|
||||
|
||||
sub max_keysize
|
||||
{
|
||||
my $self = shift;
|
||||
return unless defined $self;
|
||||
return $self->_max_keysize if ref($self);
|
||||
$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
|
||||
return _max_key_length_by_name(_trans_cipher_name($self));
|
||||
}
|
||||
|
||||
sub min_keysize {
|
||||
my $self = shift;
|
||||
return unless defined $self;
|
||||
return $self->_min_keysize if ref($self);
|
||||
$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
|
||||
return _min_key_length_by_name(_trans_cipher_name($self));
|
||||
}
|
||||
|
||||
sub default_rounds {
|
||||
my $self = shift;
|
||||
return unless defined $self;
|
||||
return $self->_default_rounds if ref($self);
|
||||
$self = _trans_cipher_name(shift) if $self eq __PACKAGE__;
|
||||
return _default_rounds_by_name(_trans_cipher_name($self));
|
||||
}
|
||||
|
||||
sub CLONE_SKIP { 1 } # prevent cloning
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher - Generic interface to cipher functions
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
#### example 1 (encrypting single block)
|
||||
use Crypt::Cipher;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $c = Crypt::Cipher->new('AES', $key);
|
||||
my $blocksize = $c->blocksize;
|
||||
my $ciphertext = $c->encrypt('plain text block'); #encrypt 1 block
|
||||
my $plaintext = $c->decrypt($ciphertext); #decrypt 1 block
|
||||
|
||||
### example 2 (using CBC mode)
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('AES');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
#### example 3 (compatibility with Crypt::CBC)
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cipher = Crypt::Cipher('AES', $key);
|
||||
my $cbc = Crypt::CBC->new( -cipher=>$cipher, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to various symetric cipher algorithms.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
Constructor, returns a reference to the cipher object.
|
||||
|
||||
## basic scenario
|
||||
$d = Crypt::Cipher->new($name, $key);
|
||||
# $name = one of 'AES', 'Anubis', 'Blowfish', 'CAST5', 'Camellia', 'DES', 'DES_EDE',
|
||||
# 'KASUMI', 'Khazad', 'MULTI2', 'Noekeon', 'RC2', 'RC5', 'RC6',
|
||||
# 'SAFERP', 'SAFER_K128', 'SAFER_K64', 'SAFER_SK128', 'SAFER_SK64',
|
||||
# 'SEED', 'Skipjack', 'Twofish', 'XTEA'
|
||||
# simply any <CNAME> for which there exists Crypt::Cipher::<NAME>
|
||||
# $key = binary key (keysize should comply with selected cipher requirements)
|
||||
|
||||
## some of the ciphers (e.g. MULTI2, RC5, SAFER) allows to set number of rounds
|
||||
$d = Crypt::Cipher->new('MULTI2', $key, $rounds);
|
||||
# $rounds = positive integer (should comply with selected cipher requirements)
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
Encrypts $plaintext and returns the $ciphertext where $plaintext and $ciphertext should be of B<blocksize> bytes.
|
||||
|
||||
$ciphertext = $d->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
Decrypts $ciphertext and returns the $plaintext where $plaintext and $ciphertext should be of B<blocksize> bytes.
|
||||
|
||||
$plaintext = $d->encrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
Just an alias for B<max_keysize> (needed for L<Crypt::CBC|Crypt::CBC> compatibility).
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
Returns the maximal allowed key size (in bytes) for given cipher.
|
||||
|
||||
$d->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher->max_keysize('AES');
|
||||
#or
|
||||
Crypt::Cipher::max_keysize('AES');
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
Returns the minimal allowed key size (in bytes) for given cipher.
|
||||
|
||||
$d->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher->min_keysize('AES');
|
||||
#or
|
||||
Crypt::Cipher::min_keysize('AES');
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
Returns block size (in bytes) for given cipher.
|
||||
|
||||
$d->blocksize;
|
||||
#or
|
||||
Crypt::Cipher->blocksize('AES');
|
||||
#or
|
||||
Crypt::Cipher::blocksize('AES');
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
Returns default number of rounds for given cipher. NOTE: only some cipher (e.g. MULTI2, RC5, SAFER) allows to set number of rounds via new().
|
||||
|
||||
$d->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher->default_rounds('AES');
|
||||
#or
|
||||
Crypt::Cipher::default_rounds('AES');
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>
|
||||
|
||||
=item * Check subclasses like L<Crypt::Cipher::AES|Crypt::Cipher::AES>, L<Crypt::Cipher::Blowfish|Crypt::Cipher::Blowfish>, ...
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::AES;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::AES - Symetric cipher AES (aka Rijndael), key size: 128/192/256 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('AES');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::AES;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::AES', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the AES cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::AES->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::AES->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::AES->keysize;
|
||||
#or
|
||||
Crypt::Cipher::AES::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::AES->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::AES::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::AES->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::AES::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::AES->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::AES::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::AES->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::AES::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Advanced_Encryption_Standard|http://en.wikipedia.org/wiki/Advanced_Encryption_Standard>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Anubis;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Anubis - Symetric cipher Anubis, key size: 128-320 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Anubis');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Anubis;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Anubis', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Anubis cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Anubis->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Anubis->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Anubis::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Anubis->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Anubis::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Anubis_(cipher)|http://en.wikipedia.org/wiki/Anubis_(cipher)>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Blowfish;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Blowfish - Symetric cipher Blowfish, key size: 64-448 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Blowfish');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Blowfish;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Blowfish', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Blowfish cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Blowfish->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Blowfish->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Blowfish::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Blowfish_(cipher)|http://en.wikipedia.org/wiki/Blowfish_(cipher)>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::CAST5;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::CAST5 - Symetric cipher CAST5 (aka CAST-128), key size: 40-128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('CAST5');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::CAST5;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::CAST5', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the CAST5 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::CAST5->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::CAST5->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5->keysize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::CAST5::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::CAST5->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::CAST5::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/CAST-128|http://en.wikipedia.org/wiki/CAST-128>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Camellia;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Camellia - Symetric cipher Camellia, key size: 128/192/256 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Camellia');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Camellia;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Camellia', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Camellia cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Camellia->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Camellia->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Camellia::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Camellia->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Camellia::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Camellia_(cipher)|http://en.wikipedia.org/wiki/Camellia_(cipher)>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::DES;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::DES - Symetric cipher DES, key size: 64[56] bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('DES');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::DES;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::DES', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the DES cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::DES->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::DES->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES->keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::DES->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::DES::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::DES->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::DES::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Data_Encryption_Standard|http://en.wikipedia.org/wiki/Data_Encryption_Standard>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::DES_EDE;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::DES_EDE - Symetric cipher DES_EDE (aka Tripple-DES, 3DES), key size: 192[168] bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('DES_EDE');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::DES_EDE;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::DES_EDE', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the DES_EDE cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::DES_EDE->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::DES_EDE->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE->keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::DES_EDE::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Triple_DES|http://en.wikipedia.org/wiki/Triple_DES>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::KASUMI;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::KASUMI - Symetric cipher KASUMI, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('KASUMI');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::KASUMI;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::KASUMI', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the KASUMI cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::KASUMI->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::KASUMI->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI->keysize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::KASUMI::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/KASUMI_(block_cipher)|http://en.wikipedia.org/wiki/KASUMI_(block_cipher)>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Khazad;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Khazad - Symetric cipher Khazad, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Khazad');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Khazad;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Khazad', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Khazad cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Khazad->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Khazad->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Khazad::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Khazad->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Khazad::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/KHAZAD|http://en.wikipedia.org/wiki/KHAZAD>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::MULTI2;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::MULTI2 - Symetric cipher MULTI2, key size: 320 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('MULTI2');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::MULTI2;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::MULTI2', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the MULTI2 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::MULTI2->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::MULTI2->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2->keysize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::MULTI2::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/MULTI2|http://en.wikipedia.org/wiki/MULTI2>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Noekeon;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Noekeon - Symetric cipher Noekeon, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Noekeon');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Noekeon;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Noekeon', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Noekeon cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Noekeon->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Noekeon->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Noekeon::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/NOEKEON|http://en.wikipedia.org/wiki/NOEKEON>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::RC2;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::RC2 - Symetric cipher RC2, key size: 64-1024 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('RC2');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::RC2;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::RC2', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the RC2 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::RC2->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::RC2->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC2->keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC2::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::RC2->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::RC2::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC2->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC2::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC2->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC2::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::RC2->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::RC2::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RC2|http://en.wikipedia.org/wiki/RC2>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::RC5;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::RC5 - Symetric cipher RC5, key size: 64-1024 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('RC5');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::RC5;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::RC5', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the RC5 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::RC5->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::RC5->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC5->keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC5::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::RC5->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::RC5::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC5->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC5::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC5->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC5::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::RC5->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::RC5::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RC5|http://en.wikipedia.org/wiki/RC5>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::RC6;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::RC6 - Symetric cipher RC6, key size: 64-1024 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('RC6');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::RC6;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::RC6', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the RC6 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::RC6->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::RC6->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC6->keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC6::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::RC6->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::RC6::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC6->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC6::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC6->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::RC6::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::RC6->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::RC6::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RC6|http://en.wikipedia.org/wiki/RC6>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::SAFERP;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::SAFERP - Symetric cipher SAFER+, key size: 128/192/256 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('SAFERP');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::SAFERP;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::SAFERP', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the SAFERP cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::SAFERP->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::SAFERP->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFERP::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SAFER|http://en.wikipedia.org/wiki/SAFER>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::SAFER_K128;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::SAFER_K128 - Symetric cipher SAFER_K128, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('SAFER_K128');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::SAFER_K128;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::SAFER_K128', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the SAFER_K128 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::SAFER_K128->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::SAFER_K128->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K128::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SAFER|http://en.wikipedia.org/wiki/SAFER>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::SAFER_K64;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::SAFER_K64 - Symetric cipher SAFER_K64, key size: 64 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('SAFER_K64');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::SAFER_K64;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::SAFER_K64', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the SAFER_K64 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::SAFER_K64->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::SAFER_K64->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_K64::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SAFER|http://en.wikipedia.org/wiki/SAFER>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::SAFER_SK128;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::SAFER_SK128 - Symetric cipher SAFER_SK128, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('SAFER_SK128');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::SAFER_SK128;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::SAFER_SK128', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the SAFER_SK128 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::SAFER_SK128->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::SAFER_SK128->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK128::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SAFER|http://en.wikipedia.org/wiki/SAFER>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::SAFER_SK64;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::SAFER_SK64 - Symetric cipher SAFER_SK64, key size: 64 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('SAFER_SK64');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::SAFER_SK64;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::SAFER_SK64', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the SAFER_SK64 cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::SAFER_SK64->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::SAFER_SK64->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SAFER_SK64::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SAFER|http://en.wikipedia.org/wiki/SAFER>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::SEED;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::SEED - Symetric cipher SEED, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('SEED');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::SEED;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::SEED', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the SEED cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::SEED->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::SEED->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SEED->keysize;
|
||||
#or
|
||||
Crypt::Cipher::SEED::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SEED->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::SEED::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SEED->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SEED::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SEED->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::SEED::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SEED->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::SEED::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SEED|http://en.wikipedia.org/wiki/SEED>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Skipjack;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Skipjack - Symetric cipher Skipjack, key size: 80 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Skipjack');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Skipjack;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Skipjack', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Skipjack cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Skipjack->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Skipjack->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Skipjack::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Skipjack_(cipher)|http://en.wikipedia.org/wiki/Skipjack_(cipher)>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::Twofish;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::Twofish - Symetric cipher Twofish, key size: 128/192/256 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('Twofish');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::Twofish;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::Twofish', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the Twofish cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::Twofish->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::Twofish->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish->keysize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::Twofish::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Twofish->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::Twofish::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Twofish|http://en.wikipedia.org/wiki/Twofish>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
package Crypt::Cipher::XTEA;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use CryptX;
|
||||
use base 'Crypt::Cipher';
|
||||
|
||||
sub blocksize { Crypt::Cipher::blocksize(__PACKAGE__) }
|
||||
sub keysize { Crypt::Cipher::keysize(__PACKAGE__) }
|
||||
sub max_keysize { Crypt::Cipher::max_keysize(__PACKAGE__) }
|
||||
sub min_keysize { Crypt::Cipher::min_keysize(__PACKAGE__) }
|
||||
sub default_rounds { Crypt::Cipher::default_rounds(__PACKAGE__) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Cipher::XTEA - Symetric cipher XTEA, key size: 128 bits (Crypt::CBC compliant)
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### example 1
|
||||
use Crypt::Mode::CBC;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::Mode::CBC->new('XTEA');
|
||||
my $ciphertext = $cbc->encrypt("secret data", $key, $iv);
|
||||
|
||||
### example 2
|
||||
use Crypt::CBC;
|
||||
use Crypt::Cipher::XTEA;
|
||||
|
||||
my $key = '...'; # length has to be valid key size for this cipher
|
||||
my $iv = '...'; # 16 bytes
|
||||
my $cbc = Crypt::CBC->new( -cipher=>'Cipher::XTEA', -key=>$key, -iv=>$iv );
|
||||
my $ciphertext = $cbc->encrypt("secret data");
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
This module implements the XTEA cipher. Provided interface is compliant with L<Crypt::CBC|Crypt::CBC> module.
|
||||
|
||||
B<BEWARE:> This module implements just elementary "one-block-(en|de)cryption" operation - if you want to
|
||||
encrypt/decrypt generic data you have to use some of the cipher block modes - check for example
|
||||
L<Crypt::Mode::CBC|Crypt::Mode::CBC>, L<Crypt::Mode::CTR|Crypt::Mode::CTR> or L<Crypt::CBC|Crypt::CBC> (which will be slower).
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
$c = Crypt::Cipher::XTEA->new($key);
|
||||
#or
|
||||
$c = Crypt::Cipher::XTEA->new($key, $rounds);
|
||||
|
||||
=head2 encrypt
|
||||
|
||||
$ciphertext = $c->encrypt($plaintext);
|
||||
|
||||
=head2 decrypt
|
||||
|
||||
$plaintext = $c->decrypt($ciphertext);
|
||||
|
||||
=head2 keysize
|
||||
|
||||
$c->keysize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA->keysize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA::keysize;
|
||||
|
||||
=head2 blocksize
|
||||
|
||||
$c->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA->blocksize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA::blocksize;
|
||||
|
||||
=head2 max_keysize
|
||||
|
||||
$c->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA->max_keysize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA::max_keysize;
|
||||
|
||||
=head2 min_keysize
|
||||
|
||||
$c->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA->min_keysize;
|
||||
#or
|
||||
Crypt::Cipher::XTEA::min_keysize;
|
||||
|
||||
=head2 default_rounds
|
||||
|
||||
$c->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::XTEA->default_rounds;
|
||||
#or
|
||||
Crypt::Cipher::XTEA::default_rounds;
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Cipher|Crypt::Cipher>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/XTEA|http://en.wikipedia.org/wiki/XTEA>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,382 @@
|
|||
package Crypt::Digest;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
require Exporter; our @ISA = qw(Exporter); ### use Exporter 'import';
|
||||
our %EXPORT_TAGS = ( all => [qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u digest_file digest_file_hex digest_file_b64 digest_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
### the following methods/functions are implemented in XS:
|
||||
# - _new
|
||||
# - _hashsize
|
||||
# - _hashsize_by_name (function, not method)
|
||||
# - clone
|
||||
# - reset
|
||||
# - digest
|
||||
# - hexdigest
|
||||
# - b64digest
|
||||
# - add
|
||||
# - DESTROY
|
||||
|
||||
sub _trans_digest_name {
|
||||
my $name = shift;
|
||||
my %trans = (
|
||||
CHAES => 'chc_hash',
|
||||
RIPEMD128 => 'rmd128',
|
||||
RIPEMD160 => 'rmd160',
|
||||
RIPEMD256 => 'rmd256',
|
||||
RIPEMD320 => 'rmd320',
|
||||
TIGER192 => 'tiger',
|
||||
SHA512_224 => 'sha512-224',
|
||||
SHA512_256 => 'sha512-256',
|
||||
SHA3_224 => 'sha3-224',
|
||||
SHA3_256 => 'sha3-256',
|
||||
SHA3_384 => 'sha3-384',
|
||||
SHA3_512 => 'sha3-512',
|
||||
BLAKE2B_160 => 'blake2b-160',
|
||||
BLAKE2B_256 => 'blake2b-256',
|
||||
BLAKE2B_384 => 'blake2b-384',
|
||||
BLAKE2B_512 => 'blake2b-512',
|
||||
BLAKE2S_128 => 'blake2s-128',
|
||||
BLAKE2S_160 => 'blake2s-160',
|
||||
BLAKE2S_224 => 'blake2s-224',
|
||||
BLAKE2S_256 => 'blake2s-256',
|
||||
);
|
||||
$name =~ s/^Crypt::Digest:://i;
|
||||
return $trans{uc($name)} if defined $trans{uc($name)};
|
||||
return lc($name);
|
||||
}
|
||||
|
||||
### METHODS
|
||||
|
||||
sub new {
|
||||
my $pkg = shift;
|
||||
unshift @_, ($pkg eq 'Crypt::Digest' ? _trans_digest_name(shift) : _trans_digest_name($pkg));
|
||||
###return _new(@_);
|
||||
goto \&_new; # keep the real caller for croak()
|
||||
}
|
||||
|
||||
sub hashsize {
|
||||
return unless defined $_[0];
|
||||
|
||||
if (ref $_[0]) {
|
||||
###return _hashsize(@_);
|
||||
goto \&_hashsize if ref $_[0]; # keep the real caller for croak()
|
||||
}
|
||||
else {
|
||||
my $pkg = shift;
|
||||
unshift @_, ($pkg eq 'Crypt::Digest' ? _trans_digest_name(shift) : _trans_digest_name($pkg));
|
||||
###return _hashsize_by_name(@_);
|
||||
goto \&_hashsize_by_name; # keep the real caller for croak()
|
||||
}
|
||||
}
|
||||
|
||||
sub addfile {
|
||||
my ($self, $file) = @_;
|
||||
|
||||
my $handle;
|
||||
if (ref(\$file) eq 'SCALAR') { #filename
|
||||
open($handle, "<", $file) || croak "FATAL: cannot open '$file': $!";
|
||||
binmode($handle);
|
||||
}
|
||||
else { #handle
|
||||
$handle = $file
|
||||
}
|
||||
croak "FATAL: invalid handle" unless defined $handle;
|
||||
|
||||
my $n;
|
||||
my $buf = "";
|
||||
while (($n = read($handle, $buf, 32*1024))) {
|
||||
$self->add($buf)
|
||||
}
|
||||
croak "FATAL: read failed: $!" unless defined $n;
|
||||
|
||||
return $self;
|
||||
}
|
||||
|
||||
sub CLONE_SKIP { 1 } # prevent cloning
|
||||
|
||||
### FUNCTIONS
|
||||
|
||||
sub digest_data { my $rv = eval {Crypt::Digest->new(shift)->add(@_)->digest}; _croak($@); $rv }
|
||||
sub digest_data_hex { my $rv = eval {Crypt::Digest->new(shift)->add(@_)->hexdigest}; _croak($@); $rv }
|
||||
sub digest_data_b64 { my $rv = eval {Crypt::Digest->new(shift)->add(@_)->b64digest}; _croak($@); $rv }
|
||||
sub digest_data_b64u { my $rv = eval {Crypt::Digest->new(shift)->add(@_)->b64udigest}; _croak($@); $rv }
|
||||
|
||||
sub digest_file { my $rv = eval {Crypt::Digest->new(shift)->addfile(@_)->digest}; _croak($@); $rv }
|
||||
sub digest_file_hex { my $rv = eval {Crypt::Digest->new(shift)->addfile(@_)->hexdigest}; _croak($@); $rv }
|
||||
sub digest_file_b64 { my $rv = eval {Crypt::Digest->new(shift)->addfile(@_)->b64digest}; _croak($@); $rv }
|
||||
sub digest_file_b64u { my $rv = eval {Crypt::Digest->new(shift)->addfile(@_)->b64udigest}; _croak($@); $rv }
|
||||
|
||||
sub _croak { #XXX-FIXME ugly hack for reporting real caller from XS croaks
|
||||
if ($_[0]) {
|
||||
$_[0] =~ s/ at .*?\.pm line \d+.[\n\r]*$//g;
|
||||
croak $_[0];
|
||||
}
|
||||
}
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest - Generic interface to hash/digest functions
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u
|
||||
digest_file digest_file_hex digest_file_b64 digest_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$digest_raw = digest_data('SHA1', 'data string');
|
||||
$digest_hex = digest_data_hex('SHA1', 'data string');
|
||||
$digest_b64 = digest_data_b64('SHA1', 'data string');
|
||||
$digest_b64u = digest_data_b64u('SHA1', 'data string');
|
||||
# calculate digest from file
|
||||
$digest_raw = digest_file('SHA1', 'filename.dat');
|
||||
$digest_hex = digest_file_hex('SHA1', 'filename.dat');
|
||||
$digest_b64 = digest_file_b64('SHA1', 'filename.dat');
|
||||
$digest_b64u = digest_file_b64u('SHA1', 'filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$digest_raw = digest_file('SHA1', *FILEHANDLE);
|
||||
$digest_hex = digest_file_hex('SHA1', *FILEHANDLE);
|
||||
$digest_b64 = digest_file_b64('SHA1', *FILEHANDLE);
|
||||
$digest_b64u = digest_file_b64u('SHA1', *FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest;
|
||||
|
||||
$d = Crypt::Digest->new('SHA1');
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to various hash/digest algorithms.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest qw( digest_data digest_data_hex digest_data_b64 digest_data_b64u
|
||||
digest_file digest_file_hex digest_file_b64 digest_file_b64u );
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
Please note that all functions take as its first argument the algoritm name, supported values are:
|
||||
|
||||
'CHAES', 'MD2', 'MD4', 'MD5', 'RIPEMD128', 'RIPEMD160',
|
||||
'RIPEMD256', 'RIPEMD320', 'SHA1', 'SHA224', 'SHA256',
|
||||
'SHA384', 'SHA512', 'SHA512_224', 'SHA512_256', 'Tiger192', 'Whirlpool',
|
||||
'SHA3_224', 'SHA3_256', 'SHA3_384', 'SHA3_512'
|
||||
|
||||
(simply any <FUNCNAME> for which there is Crypt::Digest::<FUNCNAME> module)
|
||||
|
||||
=head2 digest_data
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a binary string.
|
||||
|
||||
$digest_raw = digest_data('SHA1', 'data string');
|
||||
#or
|
||||
$digest_raw = digest_data('SHA1', 'any data', 'more data', 'even more data');
|
||||
|
||||
=head2 digest_data_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a hexadecimal string.
|
||||
|
||||
$digest_hex = digest_data_hex('SHA1', 'data string');
|
||||
#or
|
||||
$digest_hex = digest_data_hex('SHA1', 'any data', 'more data', 'even more data');
|
||||
|
||||
=head2 digest_data_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$digest_b64 = digest_data_b64('SHA1', 'data string');
|
||||
#or
|
||||
$digest_b64 = digest_data_b64('SHA1', 'any data', 'more data', 'even more data');
|
||||
|
||||
=head2 digest_data_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$digest_b64url = digest_data_b64u('SHA1', 'data string');
|
||||
#or
|
||||
$digest_b64url = digest_data_b64u('SHA1', 'any data', 'more data', 'even more data');
|
||||
|
||||
=head2 digest_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its digest encoded as a binary string.
|
||||
|
||||
$digest_raw = digest_file('SHA1', 'filename.dat');
|
||||
#or
|
||||
$digest_raw = digest_file('SHA1', *FILEHANDLE);
|
||||
|
||||
=head2 digest_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its digest encoded as a hexadecimal string.
|
||||
|
||||
$digest_hex = digest_file_hex('SHA1', 'filename.dat');
|
||||
#or
|
||||
$digest_hex = digest_file_hex('SHA1', *FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 digest_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$digest_b64 = digest_file_b64('SHA1', 'filename.dat');
|
||||
#or
|
||||
$digest_b64 = digest_file_b64('SHA1', *FILEHANDLE);
|
||||
|
||||
=head2 digest_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$digest_b64url = digest_file_b64u('SHA1', 'filename.dat');
|
||||
#or
|
||||
$digest_b64url = digest_file_b64u('SHA1', *FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
=head2 new
|
||||
|
||||
Constructor, returns a reference to the digest object.
|
||||
|
||||
$d = Crypt::Digest->new($name);
|
||||
# $name could be: 'CHAES', 'MD2', 'MD4', 'MD5', 'RIPEMD128', 'RIPEMD160',
|
||||
# 'RIPEMD256', 'RIPEMD320', 'SHA1', 'SHA224', 'SHA256', 'SHA384',
|
||||
# 'SHA512', 'SHA512_224', 'SHA512_256', 'Tiger192', 'Whirlpool'
|
||||
#
|
||||
# simply any <FUNCNAME> for which there is Crypt::Digest::<FUNCNAME> module
|
||||
|
||||
=head2 clone
|
||||
|
||||
Creates a copy of the digest object state and returns a reference to the copy.
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
Reinitialize the digest object state and returns a reference to the digest object.
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
All arguments are appended to the message we calculate digest for.
|
||||
The return value is the digest object itself.
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
Note that all the following cases are equivalent:
|
||||
|
||||
# case 1
|
||||
$d->add('aa', 'bb', 'cc');
|
||||
|
||||
# case 2
|
||||
$d->add('aa');
|
||||
$d->add('bb');
|
||||
$d->add('cc');
|
||||
|
||||
# case 3
|
||||
$d->add('aabbcc');
|
||||
|
||||
# case 4
|
||||
$d->add('aa')->add('bb')->add('cc');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
The content of the file (or filehandle) is appended to the message we calculate digest for.
|
||||
The return value is the digest object itself.
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
This method is available mostly for compatibility with other Digest::SOMETHING modules on CPAN, you are very unlikely to need it.
|
||||
The return value is the digest object itself.
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
B<BEWARE:> It is not possible to add bits that are not a multiple of 8.
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
Returns the length of calculated digest in bytes (e.g. 32 for SHA-256).
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest->hashsize('SHA1');
|
||||
#or
|
||||
Crypt::Digest::hashsize('SHA1');
|
||||
|
||||
=head2 digest
|
||||
|
||||
Returns the binary digest (raw bytes).
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
Returns the digest encoded as a hexadecimal string.
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
Returns the digest encoded as a Base64 string, B<with> trailing '=' padding (B<BEWARE:> this padding
|
||||
style might differ from other Digest::SOMETHING modules on CPAN).
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
Returns the digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>
|
||||
|
||||
=item * L<Crypt::Digest|Crypt::Digest> tries to be compatible with L<Digest|Digest> interface.
|
||||
|
||||
=item * Check subclasses like L<Crypt::Digest::SHA1|Crypt::Digest::SHA1>, L<Crypt::Digest::MD5|Crypt::Digest::MD5>, ...
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2b_160;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2b_160 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2b_160_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_160_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_160_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2b_160_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2b_160_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_160_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_160_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2b_160 - Hash function BLAKE2b [size: 160 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2b_160 qw( blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u
|
||||
blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2b_160_raw = blake2b_160('data string');
|
||||
$blake2b_160_hex = blake2b_160_hex('data string');
|
||||
$blake2b_160_b64 = blake2b_160_b64('data string');
|
||||
$blake2b_160_b64u = blake2b_160_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2b_160_raw = blake2b_160_file('filename.dat');
|
||||
$blake2b_160_hex = blake2b_160_file_hex('filename.dat');
|
||||
$blake2b_160_b64 = blake2b_160_file_b64('filename.dat');
|
||||
$blake2b_160_b64u = blake2b_160_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2b_160_raw = blake2b_160_file(*FILEHANDLE);
|
||||
$blake2b_160_hex = blake2b_160_file_hex(*FILEHANDLE);
|
||||
$blake2b_160_b64 = blake2b_160_file_b64(*FILEHANDLE);
|
||||
$blake2b_160_b64u = blake2b_160_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2b_160;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_160->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2b_160 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_160 qw(blake2b_160 blake2b_160_hex blake2b_160_b64 blake2b_160_b64u
|
||||
blake2b_160_file blake2b_160_file_hex blake2b_160_file_b64 blake2b_160_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_160 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2b_160
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a binary string.
|
||||
|
||||
$blake2b_160_raw = blake2b_160('data string');
|
||||
#or
|
||||
$blake2b_160_raw = blake2b_160('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_160_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_160_hex = blake2b_160_hex('data string');
|
||||
#or
|
||||
$blake2b_160_hex = blake2b_160_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_160_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_160_b64 = blake2b_160_b64('data string');
|
||||
#or
|
||||
$blake2b_160_b64 = blake2b_160_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_160_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_160_b64url = blake2b_160_b64u('data string');
|
||||
#or
|
||||
$blake2b_160_b64url = blake2b_160_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_160_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a binary string.
|
||||
|
||||
$blake2b_160_raw = blake2b_160_file('filename.dat');
|
||||
#or
|
||||
$blake2b_160_raw = blake2b_160_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_160_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_160_hex = blake2b_160_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2b_160_hex = blake2b_160_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2b_160_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_160_b64 = blake2b_160_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2b_160_b64 = blake2b_160_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_160_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_160_b64url = blake2b_160_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2b_160_b64url = blake2b_160_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_160->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_160->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_160::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2b_256;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2b_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2b_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2b_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2b_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2b_256 - Hash function BLAKE2b [size: 256 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2b_256 qw( blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u
|
||||
blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2b_256_raw = blake2b_256('data string');
|
||||
$blake2b_256_hex = blake2b_256_hex('data string');
|
||||
$blake2b_256_b64 = blake2b_256_b64('data string');
|
||||
$blake2b_256_b64u = blake2b_256_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2b_256_raw = blake2b_256_file('filename.dat');
|
||||
$blake2b_256_hex = blake2b_256_file_hex('filename.dat');
|
||||
$blake2b_256_b64 = blake2b_256_file_b64('filename.dat');
|
||||
$blake2b_256_b64u = blake2b_256_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2b_256_raw = blake2b_256_file(*FILEHANDLE);
|
||||
$blake2b_256_hex = blake2b_256_file_hex(*FILEHANDLE);
|
||||
$blake2b_256_b64 = blake2b_256_file_b64(*FILEHANDLE);
|
||||
$blake2b_256_b64u = blake2b_256_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2b_256;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_256->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2b_256 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_256 qw(blake2b_256 blake2b_256_hex blake2b_256_b64 blake2b_256_b64u
|
||||
blake2b_256_file blake2b_256_file_hex blake2b_256_file_b64 blake2b_256_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_256 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2b_256
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a binary string.
|
||||
|
||||
$blake2b_256_raw = blake2b_256('data string');
|
||||
#or
|
||||
$blake2b_256_raw = blake2b_256('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_256_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_256_hex = blake2b_256_hex('data string');
|
||||
#or
|
||||
$blake2b_256_hex = blake2b_256_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_256_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_256_b64 = blake2b_256_b64('data string');
|
||||
#or
|
||||
$blake2b_256_b64 = blake2b_256_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_256_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_256_b64url = blake2b_256_b64u('data string');
|
||||
#or
|
||||
$blake2b_256_b64url = blake2b_256_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_256_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a binary string.
|
||||
|
||||
$blake2b_256_raw = blake2b_256_file('filename.dat');
|
||||
#or
|
||||
$blake2b_256_raw = blake2b_256_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_256_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_256_hex = blake2b_256_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2b_256_hex = blake2b_256_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2b_256_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_256_b64 = blake2b_256_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2b_256_b64 = blake2b_256_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_256_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_256_b64url = blake2b_256_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2b_256_b64url = blake2b_256_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_256->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_256->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_256::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2b_384;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2b_384 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2b_384_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_384_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_384_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2b_384_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2b_384_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_384_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_384_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2b_384 - Hash function BLAKE2b [size: 384 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2b_384 qw( blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u
|
||||
blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2b_384_raw = blake2b_384('data string');
|
||||
$blake2b_384_hex = blake2b_384_hex('data string');
|
||||
$blake2b_384_b64 = blake2b_384_b64('data string');
|
||||
$blake2b_384_b64u = blake2b_384_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2b_384_raw = blake2b_384_file('filename.dat');
|
||||
$blake2b_384_hex = blake2b_384_file_hex('filename.dat');
|
||||
$blake2b_384_b64 = blake2b_384_file_b64('filename.dat');
|
||||
$blake2b_384_b64u = blake2b_384_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2b_384_raw = blake2b_384_file(*FILEHANDLE);
|
||||
$blake2b_384_hex = blake2b_384_file_hex(*FILEHANDLE);
|
||||
$blake2b_384_b64 = blake2b_384_file_b64(*FILEHANDLE);
|
||||
$blake2b_384_b64u = blake2b_384_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2b_384;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_384->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2b_384 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_384 qw(blake2b_384 blake2b_384_hex blake2b_384_b64 blake2b_384_b64u
|
||||
blake2b_384_file blake2b_384_file_hex blake2b_384_file_b64 blake2b_384_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_384 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2b_384
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a binary string.
|
||||
|
||||
$blake2b_384_raw = blake2b_384('data string');
|
||||
#or
|
||||
$blake2b_384_raw = blake2b_384('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_384_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_384_hex = blake2b_384_hex('data string');
|
||||
#or
|
||||
$blake2b_384_hex = blake2b_384_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_384_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_384_b64 = blake2b_384_b64('data string');
|
||||
#or
|
||||
$blake2b_384_b64 = blake2b_384_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_384_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_384_b64url = blake2b_384_b64u('data string');
|
||||
#or
|
||||
$blake2b_384_b64url = blake2b_384_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_384_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a binary string.
|
||||
|
||||
$blake2b_384_raw = blake2b_384_file('filename.dat');
|
||||
#or
|
||||
$blake2b_384_raw = blake2b_384_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_384_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_384_hex = blake2b_384_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2b_384_hex = blake2b_384_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2b_384_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_384_b64 = blake2b_384_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2b_384_b64 = blake2b_384_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_384_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_384_b64url = blake2b_384_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2b_384_b64url = blake2b_384_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_384->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_384->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_384::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2b_512;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2b_512 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2b_512_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_512_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_512_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2b_512_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2b_512_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2b_512_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2b_512_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2b_512 - Hash function BLAKE2b [size: 512 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2b_512 qw( blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u
|
||||
blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2b_512_raw = blake2b_512('data string');
|
||||
$blake2b_512_hex = blake2b_512_hex('data string');
|
||||
$blake2b_512_b64 = blake2b_512_b64('data string');
|
||||
$blake2b_512_b64u = blake2b_512_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2b_512_raw = blake2b_512_file('filename.dat');
|
||||
$blake2b_512_hex = blake2b_512_file_hex('filename.dat');
|
||||
$blake2b_512_b64 = blake2b_512_file_b64('filename.dat');
|
||||
$blake2b_512_b64u = blake2b_512_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2b_512_raw = blake2b_512_file(*FILEHANDLE);
|
||||
$blake2b_512_hex = blake2b_512_file_hex(*FILEHANDLE);
|
||||
$blake2b_512_b64 = blake2b_512_file_b64(*FILEHANDLE);
|
||||
$blake2b_512_b64u = blake2b_512_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2b_512;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_512->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2b_512 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_512 qw(blake2b_512 blake2b_512_hex blake2b_512_b64 blake2b_512_b64u
|
||||
blake2b_512_file blake2b_512_file_hex blake2b_512_file_b64 blake2b_512_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2b_512 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2b_512
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a binary string.
|
||||
|
||||
$blake2b_512_raw = blake2b_512('data string');
|
||||
#or
|
||||
$blake2b_512_raw = blake2b_512('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_512_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_512_hex = blake2b_512_hex('data string');
|
||||
#or
|
||||
$blake2b_512_hex = blake2b_512_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_512_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_512_b64 = blake2b_512_b64('data string');
|
||||
#or
|
||||
$blake2b_512_b64 = blake2b_512_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_512_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2b_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_512_b64url = blake2b_512_b64u('data string');
|
||||
#or
|
||||
$blake2b_512_b64url = blake2b_512_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2b_512_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a binary string.
|
||||
|
||||
$blake2b_512_raw = blake2b_512_file('filename.dat');
|
||||
#or
|
||||
$blake2b_512_raw = blake2b_512_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_512_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2b_512_hex = blake2b_512_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2b_512_hex = blake2b_512_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2b_512_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2b_512_b64 = blake2b_512_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2b_512_b64 = blake2b_512_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2b_512_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2b_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2b_512_b64url = blake2b_512_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2b_512_b64url = blake2b_512_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2b_512->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_512->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2b_512::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2s_128;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2s_128 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2s_128_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_128_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_128_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2s_128_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2s_128_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_128_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_128_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2s_128 - Hash function BLAKE2s [size: 128 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2s_128 qw( blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u
|
||||
blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2s_128_raw = blake2s_128('data string');
|
||||
$blake2s_128_hex = blake2s_128_hex('data string');
|
||||
$blake2s_128_b64 = blake2s_128_b64('data string');
|
||||
$blake2s_128_b64u = blake2s_128_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2s_128_raw = blake2s_128_file('filename.dat');
|
||||
$blake2s_128_hex = blake2s_128_file_hex('filename.dat');
|
||||
$blake2s_128_b64 = blake2s_128_file_b64('filename.dat');
|
||||
$blake2s_128_b64u = blake2s_128_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2s_128_raw = blake2s_128_file(*FILEHANDLE);
|
||||
$blake2s_128_hex = blake2s_128_file_hex(*FILEHANDLE);
|
||||
$blake2s_128_b64 = blake2s_128_file_b64(*FILEHANDLE);
|
||||
$blake2s_128_b64u = blake2s_128_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2s_128;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_128->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2s_128 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_128 qw(blake2s_128 blake2s_128_hex blake2s_128_b64 blake2s_128_b64u
|
||||
blake2s_128_file blake2s_128_file_hex blake2s_128_file_b64 blake2s_128_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_128 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2s_128
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a binary string.
|
||||
|
||||
$blake2s_128_raw = blake2s_128('data string');
|
||||
#or
|
||||
$blake2s_128_raw = blake2s_128('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_128_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_128_hex = blake2s_128_hex('data string');
|
||||
#or
|
||||
$blake2s_128_hex = blake2s_128_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_128_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_128_b64 = blake2s_128_b64('data string');
|
||||
#or
|
||||
$blake2s_128_b64 = blake2s_128_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_128_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_128_b64url = blake2s_128_b64u('data string');
|
||||
#or
|
||||
$blake2s_128_b64url = blake2s_128_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_128_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a binary string.
|
||||
|
||||
$blake2s_128_raw = blake2s_128_file('filename.dat');
|
||||
#or
|
||||
$blake2s_128_raw = blake2s_128_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_128_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_128_hex = blake2s_128_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2s_128_hex = blake2s_128_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2s_128_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_128_b64 = blake2s_128_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2s_128_b64 = blake2s_128_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_128_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_128_b64url = blake2s_128_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2s_128_b64url = blake2s_128_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_128->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_128->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_128::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2s_160;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2s_160 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2s_160_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_160_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_160_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2s_160_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2s_160_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_160_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_160_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2s_160 - Hash function BLAKE2s [size: 160 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2s_160 qw( blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u
|
||||
blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2s_160_raw = blake2s_160('data string');
|
||||
$blake2s_160_hex = blake2s_160_hex('data string');
|
||||
$blake2s_160_b64 = blake2s_160_b64('data string');
|
||||
$blake2s_160_b64u = blake2s_160_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2s_160_raw = blake2s_160_file('filename.dat');
|
||||
$blake2s_160_hex = blake2s_160_file_hex('filename.dat');
|
||||
$blake2s_160_b64 = blake2s_160_file_b64('filename.dat');
|
||||
$blake2s_160_b64u = blake2s_160_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2s_160_raw = blake2s_160_file(*FILEHANDLE);
|
||||
$blake2s_160_hex = blake2s_160_file_hex(*FILEHANDLE);
|
||||
$blake2s_160_b64 = blake2s_160_file_b64(*FILEHANDLE);
|
||||
$blake2s_160_b64u = blake2s_160_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2s_160;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_160->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2s_160 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_160 qw(blake2s_160 blake2s_160_hex blake2s_160_b64 blake2s_160_b64u
|
||||
blake2s_160_file blake2s_160_file_hex blake2s_160_file_b64 blake2s_160_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_160 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2s_160
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a binary string.
|
||||
|
||||
$blake2s_160_raw = blake2s_160('data string');
|
||||
#or
|
||||
$blake2s_160_raw = blake2s_160('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_160_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_160_hex = blake2s_160_hex('data string');
|
||||
#or
|
||||
$blake2s_160_hex = blake2s_160_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_160_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_160_b64 = blake2s_160_b64('data string');
|
||||
#or
|
||||
$blake2s_160_b64 = blake2s_160_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_160_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_160_b64url = blake2s_160_b64u('data string');
|
||||
#or
|
||||
$blake2s_160_b64url = blake2s_160_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_160_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a binary string.
|
||||
|
||||
$blake2s_160_raw = blake2s_160_file('filename.dat');
|
||||
#or
|
||||
$blake2s_160_raw = blake2s_160_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_160_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_160_hex = blake2s_160_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2s_160_hex = blake2s_160_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2s_160_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_160_b64 = blake2s_160_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2s_160_b64 = blake2s_160_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_160_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_160_b64url = blake2s_160_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2s_160_b64url = blake2s_160_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_160->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_160->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_160::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2s_224;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2s_224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2s_224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2s_224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2s_224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2s_224 - Hash function BLAKE2s [size: 224 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2s_224 qw( blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u
|
||||
blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2s_224_raw = blake2s_224('data string');
|
||||
$blake2s_224_hex = blake2s_224_hex('data string');
|
||||
$blake2s_224_b64 = blake2s_224_b64('data string');
|
||||
$blake2s_224_b64u = blake2s_224_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2s_224_raw = blake2s_224_file('filename.dat');
|
||||
$blake2s_224_hex = blake2s_224_file_hex('filename.dat');
|
||||
$blake2s_224_b64 = blake2s_224_file_b64('filename.dat');
|
||||
$blake2s_224_b64u = blake2s_224_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2s_224_raw = blake2s_224_file(*FILEHANDLE);
|
||||
$blake2s_224_hex = blake2s_224_file_hex(*FILEHANDLE);
|
||||
$blake2s_224_b64 = blake2s_224_file_b64(*FILEHANDLE);
|
||||
$blake2s_224_b64u = blake2s_224_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2s_224;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_224->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2s_224 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_224 qw(blake2s_224 blake2s_224_hex blake2s_224_b64 blake2s_224_b64u
|
||||
blake2s_224_file blake2s_224_file_hex blake2s_224_file_b64 blake2s_224_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_224 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2s_224
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a binary string.
|
||||
|
||||
$blake2s_224_raw = blake2s_224('data string');
|
||||
#or
|
||||
$blake2s_224_raw = blake2s_224('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_224_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_224_hex = blake2s_224_hex('data string');
|
||||
#or
|
||||
$blake2s_224_hex = blake2s_224_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_224_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_224_b64 = blake2s_224_b64('data string');
|
||||
#or
|
||||
$blake2s_224_b64 = blake2s_224_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_224_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_224_b64url = blake2s_224_b64u('data string');
|
||||
#or
|
||||
$blake2s_224_b64url = blake2s_224_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_224_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a binary string.
|
||||
|
||||
$blake2s_224_raw = blake2s_224_file('filename.dat');
|
||||
#or
|
||||
$blake2s_224_raw = blake2s_224_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_224_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_224_hex = blake2s_224_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2s_224_hex = blake2s_224_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2s_224_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_224_b64 = blake2s_224_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2s_224_b64 = blake2s_224_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_224_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_224_b64url = blake2s_224_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2s_224_b64url = blake2s_224_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_224->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_224->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_224::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package Crypt::Digest::BLAKE2s_256;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub blake2s_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub blake2s_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub blake2s_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub blake2s_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub blake2s_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub blake2s_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::BLAKE2s_256 - Hash function BLAKE2s [size: 256 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::BLAKE2s_256 qw( blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u
|
||||
blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$blake2s_256_raw = blake2s_256('data string');
|
||||
$blake2s_256_hex = blake2s_256_hex('data string');
|
||||
$blake2s_256_b64 = blake2s_256_b64('data string');
|
||||
$blake2s_256_b64u = blake2s_256_b64u('data string');
|
||||
# calculate digest from file
|
||||
$blake2s_256_raw = blake2s_256_file('filename.dat');
|
||||
$blake2s_256_hex = blake2s_256_file_hex('filename.dat');
|
||||
$blake2s_256_b64 = blake2s_256_file_b64('filename.dat');
|
||||
$blake2s_256_b64u = blake2s_256_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$blake2s_256_raw = blake2s_256_file(*FILEHANDLE);
|
||||
$blake2s_256_hex = blake2s_256_file_hex(*FILEHANDLE);
|
||||
$blake2s_256_b64 = blake2s_256_file_b64(*FILEHANDLE);
|
||||
$blake2s_256_b64u = blake2s_256_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::BLAKE2s_256;
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_256->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the BLAKE2s_256 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_256 qw(blake2s_256 blake2s_256_hex blake2s_256_b64 blake2s_256_b64u
|
||||
blake2s_256_file blake2s_256_file_hex blake2s_256_file_b64 blake2s_256_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::BLAKE2s_256 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 blake2s_256
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a binary string.
|
||||
|
||||
$blake2s_256_raw = blake2s_256('data string');
|
||||
#or
|
||||
$blake2s_256_raw = blake2s_256('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_256_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_256_hex = blake2s_256_hex('data string');
|
||||
#or
|
||||
$blake2s_256_hex = blake2s_256_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_256_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_256_b64 = blake2s_256_b64('data string');
|
||||
#or
|
||||
$blake2s_256_b64 = blake2s_256_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_256_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its BLAKE2s_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_256_b64url = blake2s_256_b64u('data string');
|
||||
#or
|
||||
$blake2s_256_b64url = blake2s_256_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 blake2s_256_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a binary string.
|
||||
|
||||
$blake2s_256_raw = blake2s_256_file('filename.dat');
|
||||
#or
|
||||
$blake2s_256_raw = blake2s_256_file(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_256_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a hexadecimal string.
|
||||
|
||||
$blake2s_256_hex = blake2s_256_file_hex('filename.dat');
|
||||
#or
|
||||
$blake2s_256_hex = blake2s_256_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 blake2s_256_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$blake2s_256_b64 = blake2s_256_file_b64('filename.dat');
|
||||
#or
|
||||
$blake2s_256_b64 = blake2s_256_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 blake2s_256_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its BLAKE2s_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$blake2s_256_b64url = blake2s_256_file_b64u('filename.dat');
|
||||
#or
|
||||
$blake2s_256_b64url = blake2s_256_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::BLAKE2s_256->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_256->hashsize();
|
||||
#or
|
||||
Crypt::Digest::BLAKE2s_256::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<https://blake2.net/|https://blake2.net/>
|
||||
|
||||
=item * L<https://tools.ietf.org/html/rfc7693|https://tools.ietf.org/html/rfc7693>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::CHAES;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( chaes chaes_hex chaes_b64 chaes_b64u chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub chaes { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub chaes_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub chaes_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub chaes_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub chaes_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub chaes_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub chaes_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub chaes_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::CHAES - Hash function - CipherHash based on AES [size: 128 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::CHAES qw( chaes chaes_hex chaes_b64 chaes_b64u
|
||||
chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$chaes_raw = chaes('data string');
|
||||
$chaes_hex = chaes_hex('data string');
|
||||
$chaes_b64 = chaes_b64('data string');
|
||||
$chaes_b64u = chaes_b64u('data string');
|
||||
# calculate digest from file
|
||||
$chaes_raw = chaes_file('filename.dat');
|
||||
$chaes_hex = chaes_file_hex('filename.dat');
|
||||
$chaes_b64 = chaes_file_b64('filename.dat');
|
||||
$chaes_b64u = chaes_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$chaes_raw = chaes_file(*FILEHANDLE);
|
||||
$chaes_hex = chaes_file_hex(*FILEHANDLE);
|
||||
$chaes_b64 = chaes_file_b64(*FILEHANDLE);
|
||||
$chaes_b64u = chaes_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::CHAES;
|
||||
|
||||
$d = Crypt::Digest::CHAES->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the CHAES digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::CHAES qw(chaes chaes_hex chaes_b64 chaes_b64u
|
||||
chaes_file chaes_file_hex chaes_file_b64 chaes_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::CHAES ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 chaes
|
||||
|
||||
Logically joins all arguments into a single string, and returns its CHAES digest encoded as a binary string.
|
||||
|
||||
$chaes_raw = chaes('data string');
|
||||
#or
|
||||
$chaes_raw = chaes('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 chaes_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its CHAES digest encoded as a hexadecimal string.
|
||||
|
||||
$chaes_hex = chaes_hex('data string');
|
||||
#or
|
||||
$chaes_hex = chaes_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 chaes_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its CHAES digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$chaes_b64 = chaes_b64('data string');
|
||||
#or
|
||||
$chaes_b64 = chaes_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 chaes_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its CHAES digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$chaes_b64url = chaes_b64u('data string');
|
||||
#or
|
||||
$chaes_b64url = chaes_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 chaes_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a binary string.
|
||||
|
||||
$chaes_raw = chaes_file('filename.dat');
|
||||
#or
|
||||
$chaes_raw = chaes_file(*FILEHANDLE);
|
||||
|
||||
=head2 chaes_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a hexadecimal string.
|
||||
|
||||
$chaes_hex = chaes_file_hex('filename.dat');
|
||||
#or
|
||||
$chaes_hex = chaes_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 chaes_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$chaes_b64 = chaes_file_b64('filename.dat');
|
||||
#or
|
||||
$chaes_b64 = chaes_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 chaes_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its CHAES digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$chaes_b64url = chaes_file_b64u('filename.dat');
|
||||
#or
|
||||
$chaes_b64url = chaes_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::CHAES->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::CHAES->hashsize();
|
||||
#or
|
||||
Crypt::Digest::CHAES::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/Cryptographic_hash_function#Hash_functions_based_on_block_ciphers|http://en.wikipedia.org/wiki/Cryptographic_hash_function#Hash_functions_based_on_block_ciphers>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::MD2;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( md2 md2_hex md2_b64 md2_b64u md2_file md2_file_hex md2_file_b64 md2_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub md2 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub md2_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub md2_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub md2_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub md2_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub md2_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub md2_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub md2_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::MD2 - Hash function MD2 [size: 128 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::MD2 qw( md2 md2_hex md2_b64 md2_b64u
|
||||
md2_file md2_file_hex md2_file_b64 md2_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$md2_raw = md2('data string');
|
||||
$md2_hex = md2_hex('data string');
|
||||
$md2_b64 = md2_b64('data string');
|
||||
$md2_b64u = md2_b64u('data string');
|
||||
# calculate digest from file
|
||||
$md2_raw = md2_file('filename.dat');
|
||||
$md2_hex = md2_file_hex('filename.dat');
|
||||
$md2_b64 = md2_file_b64('filename.dat');
|
||||
$md2_b64u = md2_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$md2_raw = md2_file(*FILEHANDLE);
|
||||
$md2_hex = md2_file_hex(*FILEHANDLE);
|
||||
$md2_b64 = md2_file_b64(*FILEHANDLE);
|
||||
$md2_b64u = md2_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::MD2;
|
||||
|
||||
$d = Crypt::Digest::MD2->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the MD2 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::MD2 qw(md2 md2_hex md2_b64 md2_b64u
|
||||
md2_file md2_file_hex md2_file_b64 md2_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::MD2 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 md2
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD2 digest encoded as a binary string.
|
||||
|
||||
$md2_raw = md2('data string');
|
||||
#or
|
||||
$md2_raw = md2('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md2_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD2 digest encoded as a hexadecimal string.
|
||||
|
||||
$md2_hex = md2_hex('data string');
|
||||
#or
|
||||
$md2_hex = md2_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md2_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD2 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$md2_b64 = md2_b64('data string');
|
||||
#or
|
||||
$md2_b64 = md2_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md2_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD2 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$md2_b64url = md2_b64u('data string');
|
||||
#or
|
||||
$md2_b64url = md2_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md2_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a binary string.
|
||||
|
||||
$md2_raw = md2_file('filename.dat');
|
||||
#or
|
||||
$md2_raw = md2_file(*FILEHANDLE);
|
||||
|
||||
=head2 md2_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a hexadecimal string.
|
||||
|
||||
$md2_hex = md2_file_hex('filename.dat');
|
||||
#or
|
||||
$md2_hex = md2_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 md2_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$md2_b64 = md2_file_b64('filename.dat');
|
||||
#or
|
||||
$md2_b64 = md2_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 md2_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD2 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$md2_b64url = md2_file_b64u('filename.dat');
|
||||
#or
|
||||
$md2_b64url = md2_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::MD2->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::MD2->hashsize();
|
||||
#or
|
||||
Crypt::Digest::MD2::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/MD2_(cryptography)|http://en.wikipedia.org/wiki/MD2_(cryptography)>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::MD4;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( md4 md4_hex md4_b64 md4_b64u md4_file md4_file_hex md4_file_b64 md4_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub md4 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub md4_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub md4_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub md4_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub md4_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub md4_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub md4_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub md4_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::MD4 - Hash function MD4 [size: 128 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::MD4 qw( md4 md4_hex md4_b64 md4_b64u
|
||||
md4_file md4_file_hex md4_file_b64 md4_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$md4_raw = md4('data string');
|
||||
$md4_hex = md4_hex('data string');
|
||||
$md4_b64 = md4_b64('data string');
|
||||
$md4_b64u = md4_b64u('data string');
|
||||
# calculate digest from file
|
||||
$md4_raw = md4_file('filename.dat');
|
||||
$md4_hex = md4_file_hex('filename.dat');
|
||||
$md4_b64 = md4_file_b64('filename.dat');
|
||||
$md4_b64u = md4_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$md4_raw = md4_file(*FILEHANDLE);
|
||||
$md4_hex = md4_file_hex(*FILEHANDLE);
|
||||
$md4_b64 = md4_file_b64(*FILEHANDLE);
|
||||
$md4_b64u = md4_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::MD4;
|
||||
|
||||
$d = Crypt::Digest::MD4->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the MD4 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::MD4 qw(md4 md4_hex md4_b64 md4_b64u
|
||||
md4_file md4_file_hex md4_file_b64 md4_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::MD4 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 md4
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD4 digest encoded as a binary string.
|
||||
|
||||
$md4_raw = md4('data string');
|
||||
#or
|
||||
$md4_raw = md4('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md4_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD4 digest encoded as a hexadecimal string.
|
||||
|
||||
$md4_hex = md4_hex('data string');
|
||||
#or
|
||||
$md4_hex = md4_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md4_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD4 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$md4_b64 = md4_b64('data string');
|
||||
#or
|
||||
$md4_b64 = md4_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md4_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD4 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$md4_b64url = md4_b64u('data string');
|
||||
#or
|
||||
$md4_b64url = md4_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md4_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a binary string.
|
||||
|
||||
$md4_raw = md4_file('filename.dat');
|
||||
#or
|
||||
$md4_raw = md4_file(*FILEHANDLE);
|
||||
|
||||
=head2 md4_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a hexadecimal string.
|
||||
|
||||
$md4_hex = md4_file_hex('filename.dat');
|
||||
#or
|
||||
$md4_hex = md4_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 md4_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$md4_b64 = md4_file_b64('filename.dat');
|
||||
#or
|
||||
$md4_b64 = md4_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 md4_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD4 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$md4_b64url = md4_file_b64u('filename.dat');
|
||||
#or
|
||||
$md4_b64url = md4_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::MD4->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::MD4->hashsize();
|
||||
#or
|
||||
Crypt::Digest::MD4::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/MD4|http://en.wikipedia.org/wiki/MD4>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::MD5;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( md5 md5_hex md5_b64 md5_b64u md5_file md5_file_hex md5_file_b64 md5_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub md5 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub md5_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub md5_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub md5_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub md5_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub md5_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub md5_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub md5_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::MD5 - Hash function MD5 [size: 128 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::MD5 qw( md5 md5_hex md5_b64 md5_b64u
|
||||
md5_file md5_file_hex md5_file_b64 md5_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$md5_raw = md5('data string');
|
||||
$md5_hex = md5_hex('data string');
|
||||
$md5_b64 = md5_b64('data string');
|
||||
$md5_b64u = md5_b64u('data string');
|
||||
# calculate digest from file
|
||||
$md5_raw = md5_file('filename.dat');
|
||||
$md5_hex = md5_file_hex('filename.dat');
|
||||
$md5_b64 = md5_file_b64('filename.dat');
|
||||
$md5_b64u = md5_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$md5_raw = md5_file(*FILEHANDLE);
|
||||
$md5_hex = md5_file_hex(*FILEHANDLE);
|
||||
$md5_b64 = md5_file_b64(*FILEHANDLE);
|
||||
$md5_b64u = md5_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::MD5;
|
||||
|
||||
$d = Crypt::Digest::MD5->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the MD5 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::MD5 qw(md5 md5_hex md5_b64 md5_b64u
|
||||
md5_file md5_file_hex md5_file_b64 md5_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::MD5 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 md5
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD5 digest encoded as a binary string.
|
||||
|
||||
$md5_raw = md5('data string');
|
||||
#or
|
||||
$md5_raw = md5('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md5_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD5 digest encoded as a hexadecimal string.
|
||||
|
||||
$md5_hex = md5_hex('data string');
|
||||
#or
|
||||
$md5_hex = md5_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md5_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD5 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$md5_b64 = md5_b64('data string');
|
||||
#or
|
||||
$md5_b64 = md5_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md5_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its MD5 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$md5_b64url = md5_b64u('data string');
|
||||
#or
|
||||
$md5_b64url = md5_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 md5_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a binary string.
|
||||
|
||||
$md5_raw = md5_file('filename.dat');
|
||||
#or
|
||||
$md5_raw = md5_file(*FILEHANDLE);
|
||||
|
||||
=head2 md5_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a hexadecimal string.
|
||||
|
||||
$md5_hex = md5_file_hex('filename.dat');
|
||||
#or
|
||||
$md5_hex = md5_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 md5_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$md5_b64 = md5_file_b64('filename.dat');
|
||||
#or
|
||||
$md5_b64 = md5_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 md5_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its MD5 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$md5_b64url = md5_file_b64u('filename.dat');
|
||||
#or
|
||||
$md5_b64url = md5_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::MD5->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::MD5->hashsize();
|
||||
#or
|
||||
Crypt::Digest::MD5::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/MD5|http://en.wikipedia.org/wiki/MD5>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::RIPEMD128;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub ripemd128 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub ripemd128_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub ripemd128_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub ripemd128_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub ripemd128_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub ripemd128_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub ripemd128_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub ripemd128_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::RIPEMD128 - Hash function RIPEMD-128 [size: 128 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::RIPEMD128 qw( ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u
|
||||
ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$ripemd128_raw = ripemd128('data string');
|
||||
$ripemd128_hex = ripemd128_hex('data string');
|
||||
$ripemd128_b64 = ripemd128_b64('data string');
|
||||
$ripemd128_b64u = ripemd128_b64u('data string');
|
||||
# calculate digest from file
|
||||
$ripemd128_raw = ripemd128_file('filename.dat');
|
||||
$ripemd128_hex = ripemd128_file_hex('filename.dat');
|
||||
$ripemd128_b64 = ripemd128_file_b64('filename.dat');
|
||||
$ripemd128_b64u = ripemd128_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$ripemd128_raw = ripemd128_file(*FILEHANDLE);
|
||||
$ripemd128_hex = ripemd128_file_hex(*FILEHANDLE);
|
||||
$ripemd128_b64 = ripemd128_file_b64(*FILEHANDLE);
|
||||
$ripemd128_b64u = ripemd128_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::RIPEMD128;
|
||||
|
||||
$d = Crypt::Digest::RIPEMD128->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the RIPEMD128 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::RIPEMD128 qw(ripemd128 ripemd128_hex ripemd128_b64 ripemd128_b64u
|
||||
ripemd128_file ripemd128_file_hex ripemd128_file_b64 ripemd128_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::RIPEMD128 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 ripemd128
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a binary string.
|
||||
|
||||
$ripemd128_raw = ripemd128('data string');
|
||||
#or
|
||||
$ripemd128_raw = ripemd128('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd128_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd128_hex = ripemd128_hex('data string');
|
||||
#or
|
||||
$ripemd128_hex = ripemd128_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd128_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd128_b64 = ripemd128_b64('data string');
|
||||
#or
|
||||
$ripemd128_b64 = ripemd128_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd128_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd128_b64url = ripemd128_b64u('data string');
|
||||
#or
|
||||
$ripemd128_b64url = ripemd128_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd128_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a binary string.
|
||||
|
||||
$ripemd128_raw = ripemd128_file('filename.dat');
|
||||
#or
|
||||
$ripemd128_raw = ripemd128_file(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd128_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd128_hex = ripemd128_file_hex('filename.dat');
|
||||
#or
|
||||
$ripemd128_hex = ripemd128_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 ripemd128_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd128_b64 = ripemd128_file_b64('filename.dat');
|
||||
#or
|
||||
$ripemd128_b64 = ripemd128_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd128_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD128 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd128_b64url = ripemd128_file_b64u('filename.dat');
|
||||
#or
|
||||
$ripemd128_b64url = ripemd128_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::RIPEMD128->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::RIPEMD128->hashsize();
|
||||
#or
|
||||
Crypt::Digest::RIPEMD128::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RIPEMD|http://en.wikipedia.org/wiki/RIPEMD>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::RIPEMD160;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub ripemd160 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub ripemd160_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub ripemd160_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub ripemd160_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub ripemd160_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub ripemd160_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub ripemd160_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub ripemd160_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::RIPEMD160 - Hash function RIPEMD-160 [size: 160 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::RIPEMD160 qw( ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u
|
||||
ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$ripemd160_raw = ripemd160('data string');
|
||||
$ripemd160_hex = ripemd160_hex('data string');
|
||||
$ripemd160_b64 = ripemd160_b64('data string');
|
||||
$ripemd160_b64u = ripemd160_b64u('data string');
|
||||
# calculate digest from file
|
||||
$ripemd160_raw = ripemd160_file('filename.dat');
|
||||
$ripemd160_hex = ripemd160_file_hex('filename.dat');
|
||||
$ripemd160_b64 = ripemd160_file_b64('filename.dat');
|
||||
$ripemd160_b64u = ripemd160_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$ripemd160_raw = ripemd160_file(*FILEHANDLE);
|
||||
$ripemd160_hex = ripemd160_file_hex(*FILEHANDLE);
|
||||
$ripemd160_b64 = ripemd160_file_b64(*FILEHANDLE);
|
||||
$ripemd160_b64u = ripemd160_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::RIPEMD160;
|
||||
|
||||
$d = Crypt::Digest::RIPEMD160->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the RIPEMD160 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::RIPEMD160 qw(ripemd160 ripemd160_hex ripemd160_b64 ripemd160_b64u
|
||||
ripemd160_file ripemd160_file_hex ripemd160_file_b64 ripemd160_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::RIPEMD160 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 ripemd160
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a binary string.
|
||||
|
||||
$ripemd160_raw = ripemd160('data string');
|
||||
#or
|
||||
$ripemd160_raw = ripemd160('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd160_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd160_hex = ripemd160_hex('data string');
|
||||
#or
|
||||
$ripemd160_hex = ripemd160_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd160_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd160_b64 = ripemd160_b64('data string');
|
||||
#or
|
||||
$ripemd160_b64 = ripemd160_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd160_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd160_b64url = ripemd160_b64u('data string');
|
||||
#or
|
||||
$ripemd160_b64url = ripemd160_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd160_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a binary string.
|
||||
|
||||
$ripemd160_raw = ripemd160_file('filename.dat');
|
||||
#or
|
||||
$ripemd160_raw = ripemd160_file(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd160_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd160_hex = ripemd160_file_hex('filename.dat');
|
||||
#or
|
||||
$ripemd160_hex = ripemd160_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 ripemd160_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd160_b64 = ripemd160_file_b64('filename.dat');
|
||||
#or
|
||||
$ripemd160_b64 = ripemd160_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd160_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD160 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd160_b64url = ripemd160_file_b64u('filename.dat');
|
||||
#or
|
||||
$ripemd160_b64url = ripemd160_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::RIPEMD160->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::RIPEMD160->hashsize();
|
||||
#or
|
||||
Crypt::Digest::RIPEMD160::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RIPEMD|http://en.wikipedia.org/wiki/RIPEMD>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::RIPEMD256;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub ripemd256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub ripemd256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub ripemd256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub ripemd256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub ripemd256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub ripemd256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub ripemd256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub ripemd256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::RIPEMD256 - Hash function RIPEMD-256 [size: 256 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::RIPEMD256 qw( ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u
|
||||
ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$ripemd256_raw = ripemd256('data string');
|
||||
$ripemd256_hex = ripemd256_hex('data string');
|
||||
$ripemd256_b64 = ripemd256_b64('data string');
|
||||
$ripemd256_b64u = ripemd256_b64u('data string');
|
||||
# calculate digest from file
|
||||
$ripemd256_raw = ripemd256_file('filename.dat');
|
||||
$ripemd256_hex = ripemd256_file_hex('filename.dat');
|
||||
$ripemd256_b64 = ripemd256_file_b64('filename.dat');
|
||||
$ripemd256_b64u = ripemd256_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$ripemd256_raw = ripemd256_file(*FILEHANDLE);
|
||||
$ripemd256_hex = ripemd256_file_hex(*FILEHANDLE);
|
||||
$ripemd256_b64 = ripemd256_file_b64(*FILEHANDLE);
|
||||
$ripemd256_b64u = ripemd256_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::RIPEMD256;
|
||||
|
||||
$d = Crypt::Digest::RIPEMD256->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the RIPEMD256 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::RIPEMD256 qw(ripemd256 ripemd256_hex ripemd256_b64 ripemd256_b64u
|
||||
ripemd256_file ripemd256_file_hex ripemd256_file_b64 ripemd256_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::RIPEMD256 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 ripemd256
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a binary string.
|
||||
|
||||
$ripemd256_raw = ripemd256('data string');
|
||||
#or
|
||||
$ripemd256_raw = ripemd256('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd256_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd256_hex = ripemd256_hex('data string');
|
||||
#or
|
||||
$ripemd256_hex = ripemd256_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd256_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd256_b64 = ripemd256_b64('data string');
|
||||
#or
|
||||
$ripemd256_b64 = ripemd256_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd256_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd256_b64url = ripemd256_b64u('data string');
|
||||
#or
|
||||
$ripemd256_b64url = ripemd256_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd256_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a binary string.
|
||||
|
||||
$ripemd256_raw = ripemd256_file('filename.dat');
|
||||
#or
|
||||
$ripemd256_raw = ripemd256_file(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd256_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd256_hex = ripemd256_file_hex('filename.dat');
|
||||
#or
|
||||
$ripemd256_hex = ripemd256_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 ripemd256_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd256_b64 = ripemd256_file_b64('filename.dat');
|
||||
#or
|
||||
$ripemd256_b64 = ripemd256_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd256_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd256_b64url = ripemd256_file_b64u('filename.dat');
|
||||
#or
|
||||
$ripemd256_b64url = ripemd256_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::RIPEMD256->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::RIPEMD256->hashsize();
|
||||
#or
|
||||
Crypt::Digest::RIPEMD256::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RIPEMD|http://en.wikipedia.org/wiki/RIPEMD>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::RIPEMD320;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub ripemd320 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub ripemd320_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub ripemd320_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub ripemd320_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub ripemd320_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub ripemd320_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub ripemd320_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub ripemd320_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::RIPEMD320 - Hash function RIPEMD-320 [size: 320 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::RIPEMD320 qw( ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u
|
||||
ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$ripemd320_raw = ripemd320('data string');
|
||||
$ripemd320_hex = ripemd320_hex('data string');
|
||||
$ripemd320_b64 = ripemd320_b64('data string');
|
||||
$ripemd320_b64u = ripemd320_b64u('data string');
|
||||
# calculate digest from file
|
||||
$ripemd320_raw = ripemd320_file('filename.dat');
|
||||
$ripemd320_hex = ripemd320_file_hex('filename.dat');
|
||||
$ripemd320_b64 = ripemd320_file_b64('filename.dat');
|
||||
$ripemd320_b64u = ripemd320_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$ripemd320_raw = ripemd320_file(*FILEHANDLE);
|
||||
$ripemd320_hex = ripemd320_file_hex(*FILEHANDLE);
|
||||
$ripemd320_b64 = ripemd320_file_b64(*FILEHANDLE);
|
||||
$ripemd320_b64u = ripemd320_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::RIPEMD320;
|
||||
|
||||
$d = Crypt::Digest::RIPEMD320->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the RIPEMD320 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::RIPEMD320 qw(ripemd320 ripemd320_hex ripemd320_b64 ripemd320_b64u
|
||||
ripemd320_file ripemd320_file_hex ripemd320_file_b64 ripemd320_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::RIPEMD320 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 ripemd320
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a binary string.
|
||||
|
||||
$ripemd320_raw = ripemd320('data string');
|
||||
#or
|
||||
$ripemd320_raw = ripemd320('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd320_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd320_hex = ripemd320_hex('data string');
|
||||
#or
|
||||
$ripemd320_hex = ripemd320_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd320_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd320_b64 = ripemd320_b64('data string');
|
||||
#or
|
||||
$ripemd320_b64 = ripemd320_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd320_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its RIPEMD320 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd320_b64url = ripemd320_b64u('data string');
|
||||
#or
|
||||
$ripemd320_b64url = ripemd320_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 ripemd320_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a binary string.
|
||||
|
||||
$ripemd320_raw = ripemd320_file('filename.dat');
|
||||
#or
|
||||
$ripemd320_raw = ripemd320_file(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd320_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a hexadecimal string.
|
||||
|
||||
$ripemd320_hex = ripemd320_file_hex('filename.dat');
|
||||
#or
|
||||
$ripemd320_hex = ripemd320_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 ripemd320_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$ripemd320_b64 = ripemd320_file_b64('filename.dat');
|
||||
#or
|
||||
$ripemd320_b64 = ripemd320_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 ripemd320_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its RIPEMD320 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$ripemd320_b64url = ripemd320_file_b64u('filename.dat');
|
||||
#or
|
||||
$ripemd320_b64url = ripemd320_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::RIPEMD320->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::RIPEMD320->hashsize();
|
||||
#or
|
||||
Crypt::Digest::RIPEMD320::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/RIPEMD|http://en.wikipedia.org/wiki/RIPEMD>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA1;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha1 sha1_hex sha1_b64 sha1_b64u sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha1 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha1_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha1_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha1_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha1_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha1_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha1_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha1_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA1 - Hash function SHA-1 [size: 160 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA1 qw( sha1 sha1_hex sha1_b64 sha1_b64u
|
||||
sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha1_raw = sha1('data string');
|
||||
$sha1_hex = sha1_hex('data string');
|
||||
$sha1_b64 = sha1_b64('data string');
|
||||
$sha1_b64u = sha1_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha1_raw = sha1_file('filename.dat');
|
||||
$sha1_hex = sha1_file_hex('filename.dat');
|
||||
$sha1_b64 = sha1_file_b64('filename.dat');
|
||||
$sha1_b64u = sha1_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha1_raw = sha1_file(*FILEHANDLE);
|
||||
$sha1_hex = sha1_file_hex(*FILEHANDLE);
|
||||
$sha1_b64 = sha1_file_b64(*FILEHANDLE);
|
||||
$sha1_b64u = sha1_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA1;
|
||||
|
||||
$d = Crypt::Digest::SHA1->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA1 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA1 qw(sha1 sha1_hex sha1_b64 sha1_b64u
|
||||
sha1_file sha1_file_hex sha1_file_b64 sha1_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA1 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha1
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a binary string.
|
||||
|
||||
$sha1_raw = sha1('data string');
|
||||
#or
|
||||
$sha1_raw = sha1('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha1_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha1_hex = sha1_hex('data string');
|
||||
#or
|
||||
$sha1_hex = sha1_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha1_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha1_b64 = sha1_b64('data string');
|
||||
#or
|
||||
$sha1_b64 = sha1_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha1_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA1 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha1_b64url = sha1_b64u('data string');
|
||||
#or
|
||||
$sha1_b64url = sha1_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha1_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a binary string.
|
||||
|
||||
$sha1_raw = sha1_file('filename.dat');
|
||||
#or
|
||||
$sha1_raw = sha1_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha1_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha1_hex = sha1_file_hex('filename.dat');
|
||||
#or
|
||||
$sha1_hex = sha1_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha1_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha1_b64 = sha1_file_b64('filename.dat');
|
||||
#or
|
||||
$sha1_b64 = sha1_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha1_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA1 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha1_b64url = sha1_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha1_b64url = sha1_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA1->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA1->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA1::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-1|http://en.wikipedia.org/wiki/SHA-1>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA224;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha224 sha224_hex sha224_b64 sha224_b64u sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA224 - Hash function SHA-224 [size: 224 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA224 qw( sha224 sha224_hex sha224_b64 sha224_b64u
|
||||
sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha224_raw = sha224('data string');
|
||||
$sha224_hex = sha224_hex('data string');
|
||||
$sha224_b64 = sha224_b64('data string');
|
||||
$sha224_b64u = sha224_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha224_raw = sha224_file('filename.dat');
|
||||
$sha224_hex = sha224_file_hex('filename.dat');
|
||||
$sha224_b64 = sha224_file_b64('filename.dat');
|
||||
$sha224_b64u = sha224_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha224_raw = sha224_file(*FILEHANDLE);
|
||||
$sha224_hex = sha224_file_hex(*FILEHANDLE);
|
||||
$sha224_b64 = sha224_file_b64(*FILEHANDLE);
|
||||
$sha224_b64u = sha224_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA224;
|
||||
|
||||
$d = Crypt::Digest::SHA224->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA224 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA224 qw(sha224 sha224_hex sha224_b64 sha224_b64u
|
||||
sha224_file sha224_file_hex sha224_file_b64 sha224_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA224 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha224
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a binary string.
|
||||
|
||||
$sha224_raw = sha224('data string');
|
||||
#or
|
||||
$sha224_raw = sha224('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha224_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha224_hex = sha224_hex('data string');
|
||||
#or
|
||||
$sha224_hex = sha224_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha224_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha224_b64 = sha224_b64('data string');
|
||||
#or
|
||||
$sha224_b64 = sha224_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha224_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha224_b64url = sha224_b64u('data string');
|
||||
#or
|
||||
$sha224_b64url = sha224_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha224_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a binary string.
|
||||
|
||||
$sha224_raw = sha224_file('filename.dat');
|
||||
#or
|
||||
$sha224_raw = sha224_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha224_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha224_hex = sha224_file_hex('filename.dat');
|
||||
#or
|
||||
$sha224_hex = sha224_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha224_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha224_b64 = sha224_file_b64('filename.dat');
|
||||
#or
|
||||
$sha224_b64 = sha224_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha224_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha224_b64url = sha224_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha224_b64url = sha224_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA224->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA224->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA224::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-2|http://en.wikipedia.org/wiki/SHA-2>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA256;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha256 sha256_hex sha256_b64 sha256_b64u sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA256 - Hash function SHA-256 [size: 256 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA256 qw( sha256 sha256_hex sha256_b64 sha256_b64u
|
||||
sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha256_raw = sha256('data string');
|
||||
$sha256_hex = sha256_hex('data string');
|
||||
$sha256_b64 = sha256_b64('data string');
|
||||
$sha256_b64u = sha256_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha256_raw = sha256_file('filename.dat');
|
||||
$sha256_hex = sha256_file_hex('filename.dat');
|
||||
$sha256_b64 = sha256_file_b64('filename.dat');
|
||||
$sha256_b64u = sha256_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha256_raw = sha256_file(*FILEHANDLE);
|
||||
$sha256_hex = sha256_file_hex(*FILEHANDLE);
|
||||
$sha256_b64 = sha256_file_b64(*FILEHANDLE);
|
||||
$sha256_b64u = sha256_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA256;
|
||||
|
||||
$d = Crypt::Digest::SHA256->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA256 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA256 qw(sha256 sha256_hex sha256_b64 sha256_b64u
|
||||
sha256_file sha256_file_hex sha256_file_b64 sha256_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA256 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha256
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a binary string.
|
||||
|
||||
$sha256_raw = sha256('data string');
|
||||
#or
|
||||
$sha256_raw = sha256('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha256_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha256_hex = sha256_hex('data string');
|
||||
#or
|
||||
$sha256_hex = sha256_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha256_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha256_b64 = sha256_b64('data string');
|
||||
#or
|
||||
$sha256_b64 = sha256_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha256_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha256_b64url = sha256_b64u('data string');
|
||||
#or
|
||||
$sha256_b64url = sha256_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha256_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a binary string.
|
||||
|
||||
$sha256_raw = sha256_file('filename.dat');
|
||||
#or
|
||||
$sha256_raw = sha256_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha256_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha256_hex = sha256_file_hex('filename.dat');
|
||||
#or
|
||||
$sha256_hex = sha256_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha256_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha256_b64 = sha256_file_b64('filename.dat');
|
||||
#or
|
||||
$sha256_b64 = sha256_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha256_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha256_b64url = sha256_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha256_b64url = sha256_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA256->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA256->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA256::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-2|http://en.wikipedia.org/wiki/SHA-2>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA384;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha384 sha384_hex sha384_b64 sha384_b64u sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha384 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha384_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha384_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha384_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha384_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha384_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha384_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha384_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA384 - Hash function SHA-384 [size: 384 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA384 qw( sha384 sha384_hex sha384_b64 sha384_b64u
|
||||
sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha384_raw = sha384('data string');
|
||||
$sha384_hex = sha384_hex('data string');
|
||||
$sha384_b64 = sha384_b64('data string');
|
||||
$sha384_b64u = sha384_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha384_raw = sha384_file('filename.dat');
|
||||
$sha384_hex = sha384_file_hex('filename.dat');
|
||||
$sha384_b64 = sha384_file_b64('filename.dat');
|
||||
$sha384_b64u = sha384_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha384_raw = sha384_file(*FILEHANDLE);
|
||||
$sha384_hex = sha384_file_hex(*FILEHANDLE);
|
||||
$sha384_b64 = sha384_file_b64(*FILEHANDLE);
|
||||
$sha384_b64u = sha384_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA384;
|
||||
|
||||
$d = Crypt::Digest::SHA384->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA384 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA384 qw(sha384 sha384_hex sha384_b64 sha384_b64u
|
||||
sha384_file sha384_file_hex sha384_file_b64 sha384_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA384 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha384
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a binary string.
|
||||
|
||||
$sha384_raw = sha384('data string');
|
||||
#or
|
||||
$sha384_raw = sha384('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha384_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha384_hex = sha384_hex('data string');
|
||||
#or
|
||||
$sha384_hex = sha384_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha384_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha384_b64 = sha384_b64('data string');
|
||||
#or
|
||||
$sha384_b64 = sha384_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha384_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha384_b64url = sha384_b64u('data string');
|
||||
#or
|
||||
$sha384_b64url = sha384_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha384_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a binary string.
|
||||
|
||||
$sha384_raw = sha384_file('filename.dat');
|
||||
#or
|
||||
$sha384_raw = sha384_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha384_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha384_hex = sha384_file_hex('filename.dat');
|
||||
#or
|
||||
$sha384_hex = sha384_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha384_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha384_b64 = sha384_file_b64('filename.dat');
|
||||
#or
|
||||
$sha384_b64 = sha384_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha384_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha384_b64url = sha384_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha384_b64url = sha384_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA384->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA384->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA384::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-2|http://en.wikipedia.org/wiki/SHA-2>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA3_224;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha3_224 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha3_224_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha3_224_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha3_224_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha3_224_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha3_224_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha3_224_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha3_224_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA3_224 - Hash function SHA3-224 [size: 224 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA3_224 qw( sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u
|
||||
sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha3_224_raw = sha3_224('data string');
|
||||
$sha3_224_hex = sha3_224_hex('data string');
|
||||
$sha3_224_b64 = sha3_224_b64('data string');
|
||||
$sha3_224_b64u = sha3_224_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha3_224_raw = sha3_224_file('filename.dat');
|
||||
$sha3_224_hex = sha3_224_file_hex('filename.dat');
|
||||
$sha3_224_b64 = sha3_224_file_b64('filename.dat');
|
||||
$sha3_224_b64u = sha3_224_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha3_224_raw = sha3_224_file(*FILEHANDLE);
|
||||
$sha3_224_hex = sha3_224_file_hex(*FILEHANDLE);
|
||||
$sha3_224_b64 = sha3_224_file_b64(*FILEHANDLE);
|
||||
$sha3_224_b64u = sha3_224_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA3_224;
|
||||
|
||||
$d = Crypt::Digest::SHA3_224->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA3_224 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA3_224 qw(sha3_224 sha3_224_hex sha3_224_b64 sha3_224_b64u
|
||||
sha3_224_file sha3_224_file_hex sha3_224_file_b64 sha3_224_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA3_224 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha3_224
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a binary string.
|
||||
|
||||
$sha3_224_raw = sha3_224('data string');
|
||||
#or
|
||||
$sha3_224_raw = sha3_224('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_224_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_224_hex = sha3_224_hex('data string');
|
||||
#or
|
||||
$sha3_224_hex = sha3_224_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_224_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_224_b64 = sha3_224_b64('data string');
|
||||
#or
|
||||
$sha3_224_b64 = sha3_224_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_224_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_224_b64url = sha3_224_b64u('data string');
|
||||
#or
|
||||
$sha3_224_b64url = sha3_224_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_224_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a binary string.
|
||||
|
||||
$sha3_224_raw = sha3_224_file('filename.dat');
|
||||
#or
|
||||
$sha3_224_raw = sha3_224_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_224_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_224_hex = sha3_224_file_hex('filename.dat');
|
||||
#or
|
||||
$sha3_224_hex = sha3_224_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha3_224_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_224_b64 = sha3_224_file_b64('filename.dat');
|
||||
#or
|
||||
$sha3_224_b64 = sha3_224_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_224_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_224 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_224_b64url = sha3_224_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha3_224_b64url = sha3_224_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA3_224->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA3_224->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA3_224::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-3|http://en.wikipedia.org/wiki/SHA-3>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA3_256;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha3_256 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha3_256_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha3_256_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha3_256_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha3_256_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha3_256_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha3_256_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha3_256_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA3_256 - Hash function SHA3-256 [size: 256 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA3_256 qw( sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u
|
||||
sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha3_256_raw = sha3_256('data string');
|
||||
$sha3_256_hex = sha3_256_hex('data string');
|
||||
$sha3_256_b64 = sha3_256_b64('data string');
|
||||
$sha3_256_b64u = sha3_256_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha3_256_raw = sha3_256_file('filename.dat');
|
||||
$sha3_256_hex = sha3_256_file_hex('filename.dat');
|
||||
$sha3_256_b64 = sha3_256_file_b64('filename.dat');
|
||||
$sha3_256_b64u = sha3_256_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha3_256_raw = sha3_256_file(*FILEHANDLE);
|
||||
$sha3_256_hex = sha3_256_file_hex(*FILEHANDLE);
|
||||
$sha3_256_b64 = sha3_256_file_b64(*FILEHANDLE);
|
||||
$sha3_256_b64u = sha3_256_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA3_256;
|
||||
|
||||
$d = Crypt::Digest::SHA3_256->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA3_256 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA3_256 qw(sha3_256 sha3_256_hex sha3_256_b64 sha3_256_b64u
|
||||
sha3_256_file sha3_256_file_hex sha3_256_file_b64 sha3_256_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA3_256 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha3_256
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a binary string.
|
||||
|
||||
$sha3_256_raw = sha3_256('data string');
|
||||
#or
|
||||
$sha3_256_raw = sha3_256('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_256_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_256_hex = sha3_256_hex('data string');
|
||||
#or
|
||||
$sha3_256_hex = sha3_256_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_256_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_256_b64 = sha3_256_b64('data string');
|
||||
#or
|
||||
$sha3_256_b64 = sha3_256_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_256_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_256_b64url = sha3_256_b64u('data string');
|
||||
#or
|
||||
$sha3_256_b64url = sha3_256_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_256_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a binary string.
|
||||
|
||||
$sha3_256_raw = sha3_256_file('filename.dat');
|
||||
#or
|
||||
$sha3_256_raw = sha3_256_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_256_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_256_hex = sha3_256_file_hex('filename.dat');
|
||||
#or
|
||||
$sha3_256_hex = sha3_256_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha3_256_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_256_b64 = sha3_256_file_b64('filename.dat');
|
||||
#or
|
||||
$sha3_256_b64 = sha3_256_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_256_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_256 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_256_b64url = sha3_256_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha3_256_b64url = sha3_256_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA3_256->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA3_256->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA3_256::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-3|http://en.wikipedia.org/wiki/SHA-3>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA3_384;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha3_384 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha3_384_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha3_384_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha3_384_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha3_384_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha3_384_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha3_384_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha3_384_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA3_384 - Hash function SHA3-384 [size: 384 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA3_384 qw( sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u
|
||||
sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha3_384_raw = sha3_384('data string');
|
||||
$sha3_384_hex = sha3_384_hex('data string');
|
||||
$sha3_384_b64 = sha3_384_b64('data string');
|
||||
$sha3_384_b64u = sha3_384_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha3_384_raw = sha3_384_file('filename.dat');
|
||||
$sha3_384_hex = sha3_384_file_hex('filename.dat');
|
||||
$sha3_384_b64 = sha3_384_file_b64('filename.dat');
|
||||
$sha3_384_b64u = sha3_384_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha3_384_raw = sha3_384_file(*FILEHANDLE);
|
||||
$sha3_384_hex = sha3_384_file_hex(*FILEHANDLE);
|
||||
$sha3_384_b64 = sha3_384_file_b64(*FILEHANDLE);
|
||||
$sha3_384_b64u = sha3_384_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA3_384;
|
||||
|
||||
$d = Crypt::Digest::SHA3_384->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA3_384 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA3_384 qw(sha3_384 sha3_384_hex sha3_384_b64 sha3_384_b64u
|
||||
sha3_384_file sha3_384_file_hex sha3_384_file_b64 sha3_384_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA3_384 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha3_384
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a binary string.
|
||||
|
||||
$sha3_384_raw = sha3_384('data string');
|
||||
#or
|
||||
$sha3_384_raw = sha3_384('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_384_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_384_hex = sha3_384_hex('data string');
|
||||
#or
|
||||
$sha3_384_hex = sha3_384_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_384_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_384_b64 = sha3_384_b64('data string');
|
||||
#or
|
||||
$sha3_384_b64 = sha3_384_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_384_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_384_b64url = sha3_384_b64u('data string');
|
||||
#or
|
||||
$sha3_384_b64url = sha3_384_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_384_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a binary string.
|
||||
|
||||
$sha3_384_raw = sha3_384_file('filename.dat');
|
||||
#or
|
||||
$sha3_384_raw = sha3_384_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_384_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_384_hex = sha3_384_file_hex('filename.dat');
|
||||
#or
|
||||
$sha3_384_hex = sha3_384_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha3_384_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_384_b64 = sha3_384_file_b64('filename.dat');
|
||||
#or
|
||||
$sha3_384_b64 = sha3_384_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_384_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_384 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_384_b64url = sha3_384_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha3_384_b64url = sha3_384_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA3_384->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA3_384->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA3_384::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-3|http://en.wikipedia.org/wiki/SHA-3>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
package Crypt::Digest::SHA3_512;
|
||||
|
||||
### BEWARE - GENERATED FILE, DO NOT EDIT MANUALLY!
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
our $VERSION = '0.048';
|
||||
|
||||
use base qw(Crypt::Digest Exporter);
|
||||
our %EXPORT_TAGS = ( all => [qw( sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u )] );
|
||||
our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
|
||||
our @EXPORT = qw();
|
||||
|
||||
use Carp;
|
||||
$Carp::Internal{(__PACKAGE__)}++;
|
||||
use CryptX;
|
||||
|
||||
sub hashsize { Crypt::Digest::hashsize(__PACKAGE__) }
|
||||
|
||||
sub sha3_512 { Crypt::Digest::digest_data(__PACKAGE__, @_) }
|
||||
sub sha3_512_hex { Crypt::Digest::digest_data_hex(__PACKAGE__, @_) }
|
||||
sub sha3_512_b64 { Crypt::Digest::digest_data_b64(__PACKAGE__, @_) }
|
||||
sub sha3_512_b64u { Crypt::Digest::digest_data_b64u(__PACKAGE__, @_) }
|
||||
|
||||
sub sha3_512_file { Crypt::Digest::digest_file(__PACKAGE__, @_) }
|
||||
sub sha3_512_file_hex { Crypt::Digest::digest_file_hex(__PACKAGE__, @_) }
|
||||
sub sha3_512_file_b64 { Crypt::Digest::digest_file_b64(__PACKAGE__, @_) }
|
||||
sub sha3_512_file_b64u { Crypt::Digest::digest_file_b64u(__PACKAGE__, @_) }
|
||||
|
||||
1;
|
||||
|
||||
=pod
|
||||
|
||||
=head1 NAME
|
||||
|
||||
Crypt::Digest::SHA3_512 - Hash function SHA3-512 [size: 512 bits]
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
### Functional interface:
|
||||
use Crypt::Digest::SHA3_512 qw( sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u
|
||||
sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u );
|
||||
|
||||
# calculate digest from string/buffer
|
||||
$sha3_512_raw = sha3_512('data string');
|
||||
$sha3_512_hex = sha3_512_hex('data string');
|
||||
$sha3_512_b64 = sha3_512_b64('data string');
|
||||
$sha3_512_b64u = sha3_512_b64u('data string');
|
||||
# calculate digest from file
|
||||
$sha3_512_raw = sha3_512_file('filename.dat');
|
||||
$sha3_512_hex = sha3_512_file_hex('filename.dat');
|
||||
$sha3_512_b64 = sha3_512_file_b64('filename.dat');
|
||||
$sha3_512_b64u = sha3_512_file_b64u('filename.dat');
|
||||
# calculate digest from filehandle
|
||||
$sha3_512_raw = sha3_512_file(*FILEHANDLE);
|
||||
$sha3_512_hex = sha3_512_file_hex(*FILEHANDLE);
|
||||
$sha3_512_b64 = sha3_512_file_b64(*FILEHANDLE);
|
||||
$sha3_512_b64u = sha3_512_file_b64u(*FILEHANDLE);
|
||||
|
||||
### OO interface:
|
||||
use Crypt::Digest::SHA3_512;
|
||||
|
||||
$d = Crypt::Digest::SHA3_512->new;
|
||||
$d->add('any data');
|
||||
$d->addfile('filename.dat');
|
||||
$d->addfile(*FILEHANDLE);
|
||||
$result_raw = $d->digest; # raw bytes
|
||||
$result_hex = $d->hexdigest; # hexadecimal form
|
||||
$result_b64 = $d->b64digest; # Base64 form
|
||||
$result_b64u = $d->b64udigest; # Base64 URL Safe form
|
||||
|
||||
=head1 DESCRIPTION
|
||||
|
||||
Provides an interface to the SHA3_512 digest algorithm.
|
||||
|
||||
=head1 EXPORT
|
||||
|
||||
Nothing is exported by default.
|
||||
|
||||
You can export selected functions:
|
||||
|
||||
use Crypt::Digest::SHA3_512 qw(sha3_512 sha3_512_hex sha3_512_b64 sha3_512_b64u
|
||||
sha3_512_file sha3_512_file_hex sha3_512_file_b64 sha3_512_file_b64u);
|
||||
|
||||
Or all of them at once:
|
||||
|
||||
use Crypt::Digest::SHA3_512 ':all';
|
||||
|
||||
=head1 FUNCTIONS
|
||||
|
||||
=head2 sha3_512
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a binary string.
|
||||
|
||||
$sha3_512_raw = sha3_512('data string');
|
||||
#or
|
||||
$sha3_512_raw = sha3_512('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_512_hex
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_512_hex = sha3_512_hex('data string');
|
||||
#or
|
||||
$sha3_512_hex = sha3_512_hex('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_512_b64
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_512_b64 = sha3_512_b64('data string');
|
||||
#or
|
||||
$sha3_512_b64 = sha3_512_b64('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_512_b64u
|
||||
|
||||
Logically joins all arguments into a single string, and returns its SHA3_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_512_b64url = sha3_512_b64u('data string');
|
||||
#or
|
||||
$sha3_512_b64url = sha3_512_b64u('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 sha3_512_file
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a binary string.
|
||||
|
||||
$sha3_512_raw = sha3_512_file('filename.dat');
|
||||
#or
|
||||
$sha3_512_raw = sha3_512_file(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_512_file_hex
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a hexadecimal string.
|
||||
|
||||
$sha3_512_hex = sha3_512_file_hex('filename.dat');
|
||||
#or
|
||||
$sha3_512_hex = sha3_512_file_hex(*FILEHANDLE);
|
||||
|
||||
B<BEWARE:> You have to make sure that the filehandle is in binary mode before you pass it as argument to the addfile() method.
|
||||
|
||||
=head2 sha3_512_file_b64
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a Base64 string, B<with> trailing '=' padding.
|
||||
|
||||
$sha3_512_b64 = sha3_512_file_b64('filename.dat');
|
||||
#or
|
||||
$sha3_512_b64 = sha3_512_file_b64(*FILEHANDLE);
|
||||
|
||||
=head2 sha3_512_file_b64u
|
||||
|
||||
Reads file (defined by filename or filehandle) content, and returns its SHA3_512 digest encoded as a Base64 URL Safe string (see RFC 4648 section 5).
|
||||
|
||||
$sha3_512_b64url = sha3_512_file_b64u('filename.dat');
|
||||
#or
|
||||
$sha3_512_b64url = sha3_512_file_b64u(*FILEHANDLE);
|
||||
|
||||
=head1 METHODS
|
||||
|
||||
The OO interface provides the same set of functions as L<Crypt::Digest>.
|
||||
|
||||
=head2 new
|
||||
|
||||
$d = Crypt::Digest::SHA3_512->new();
|
||||
|
||||
=head2 clone
|
||||
|
||||
$d->clone();
|
||||
|
||||
=head2 reset
|
||||
|
||||
$d->reset();
|
||||
|
||||
=head2 add
|
||||
|
||||
$d->add('any data');
|
||||
#or
|
||||
$d->add('any data', 'more data', 'even more data');
|
||||
|
||||
=head2 addfile
|
||||
|
||||
$d->addfile('filename.dat');
|
||||
#or
|
||||
$d->addfile(*FILEHANDLE);
|
||||
|
||||
=head2 add_bits
|
||||
|
||||
$d->add_bits($bit_string); # e.g. $d->add_bits("111100001010");
|
||||
#or
|
||||
$d->add_bits($data, $nbits); # e.g. $d->add_bits("\xF0\xA0", 16);
|
||||
|
||||
=head2 hashsize
|
||||
|
||||
$d->hashsize;
|
||||
#or
|
||||
Crypt::Digest::SHA3_512->hashsize();
|
||||
#or
|
||||
Crypt::Digest::SHA3_512::hashsize();
|
||||
|
||||
=head2 digest
|
||||
|
||||
$result_raw = $d->digest();
|
||||
|
||||
=head2 hexdigest
|
||||
|
||||
$result_hex = $d->hexdigest();
|
||||
|
||||
=head2 b64digest
|
||||
|
||||
$result_b64 = $d->b64digest();
|
||||
|
||||
=head2 b64udigest
|
||||
|
||||
$result_b64url = $d->b64udigest();
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
=over
|
||||
|
||||
=item * L<CryptX|CryptX>, L<Crypt::Digest|Crypt::Digest>
|
||||
|
||||
=item * L<http://en.wikipedia.org/wiki/SHA-3|http://en.wikipedia.org/wiki/SHA-3>
|
||||
|
||||
=back
|
||||
|
||||
=cut
|
||||
|
||||
__END__
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue