atmos/codecrypt
1
0
Fork 0
mirror of https://github.com/biergaizi/codecrypt synced 2024-06-27 01:08:15 +00:00
Code Issues Releases Wiki Activity

algos_sig: new cubehash-based algorithms

Browse Source
This commit is contained in:
Mirek Kratochvil 2013-09-29 20:53:24 +02:00
parent c65557724e
commit 72bcc1080a
3 changed files with 344 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/algo_suite.cpp
View File

@ -37,5 +37,11 @@ void fill_algorithm_suite (algorithm_suite&s)
do_alg (algo_mceqd128cube);
do_alg (algo_mceqd192cube);
do_alg (algo_mceqd256cube);
do_alg (algo_fmtseq128cube);
do_alg (algo_fmtseq192cube);
do_alg (algo_fmtseq256cube);
do_alg (algo_fmtseq128h20cube);
do_alg (algo_fmtseq192h20cube);
do_alg (algo_fmtseq256h20cube);
#undef do_alg
}

276
src/algos_sig.cpp
View File

@ -90,11 +90,11 @@ static void msg_pad (const bvector&in, std::vector<byte>&out, size_t minsize)
*/
template <int h, int l, int hs, class message_hash, class tree_hash>
int fmtseq_generic_sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
static int fmtseq_generic_sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
//load the key
fmtseq::privkey Priv;
@ -131,9 +131,9 @@ int fmtseq_generic_sign (const bvector&msg,
}
template <int h, int l, int hs, class message_hash, class tree_hash>
int fmtseq_generic_verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
static int fmtseq_generic_verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
//load the key
fmtseq::pubkey Pub;
@ -161,6 +161,23 @@ int fmtseq_generic_verify (const bvector&sig,
return 0;
}
template<class treehash, int hs, int h, int l>
static int fmtseq_create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
treehash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, hs, h, l) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
}
/*
* actual instantiations
*/
@ -227,47 +244,20 @@ int algo_fmtseq256::verify (const bvector&sig,
int algo_fmtseq128::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
rmd128hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 256, 4, 4) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
return fmtseq_create_keypair<rmd128hash, 256, 4, 4>
(pub, priv, rng);
}
int algo_fmtseq192::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
tiger192hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 384, 4, 4) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
return fmtseq_create_keypair<tiger192hash, 384, 4, 4>
(pub, priv, rng);
}
int algo_fmtseq256::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
sha256hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 512, 4, 4) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
return fmtseq_create_keypair<sha256hash, 512, 4, 4>
(pub, priv, rng);
}
/*
@ -339,46 +329,184 @@ int algo_fmtseq256h20::verify (const bvector&sig,
int algo_fmtseq128h20::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
rmd128hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 256, 4, 5) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
return fmtseq_create_keypair<rmd128hash, 256, 4, 5>
(pub, priv, rng);
}
int algo_fmtseq192h20::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
tiger192hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 384, 4, 5) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
return fmtseq_create_keypair<tiger192hash, 384, 4, 5>
(pub, priv, rng);
}
int algo_fmtseq256h20::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
fmtseq::pubkey Pub;
fmtseq::privkey Priv;
sha256hash hf;
if (fmtseq::generate (Pub, Priv, rng, hf, 512, 4, 5) )
return 1;
*pub = Pub.serialize();
*priv = Priv.serialize();
return 0;
return fmtseq_create_keypair<sha256hash, 512, 4, 5>
(pub, priv, rng);
}
/*
* CubeHash variants of everything above.
*/
#include "cube_hash.h"
int algo_fmtseq128cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 4, 256, cube256hash, cube128hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq128cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 4, 256, cube256hash, cube128hash>
(sig, msg, pubkey);
}
int algo_fmtseq192cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 4, 384, cube384hash, cube192hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq192cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 4, 384, cube384hash, cube192hash>
(sig, msg, pubkey);
}
int algo_fmtseq256cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 4, 512, cube512hash, cube256hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq256cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 4, 512, cube512hash, cube256hash>
(sig, msg, pubkey);
}
int algo_fmtseq128cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube128hash, 256, 4, 4>
(pub, priv, rng);
}
int algo_fmtseq192cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube192hash, 384, 4, 4>
(pub, priv, rng);
}
int algo_fmtseq256cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube256hash, 512, 4, 4>
(pub, priv, rng);
}
/*
* h=20 variants with cubehash.
*/
int algo_fmtseq128h20cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 5, 256, cube256hash, cube128hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq128h20cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 5, 256, cube256hash, cube128hash>
(sig, msg, pubkey);
}
int algo_fmtseq192h20cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 5, 384, cube384hash, cube192hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq192h20cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 5, 384, cube384hash, cube192hash>
(sig, msg, pubkey);
}
int algo_fmtseq256h20cube::sign (const bvector&msg,
bvector&sig,
sencode**privkey,
bool&dirty,
prng&rng)
{
return fmtseq_generic_sign
<4, 5, 512, cube512hash, cube256hash>
(msg, sig, privkey, dirty, rng);
}
int algo_fmtseq256h20cube::verify (const bvector&sig,
const bvector&msg,
sencode*pubkey)
{
return fmtseq_generic_verify
<4, 5, 512, cube512hash, cube256hash>
(sig, msg, pubkey);
}
int algo_fmtseq128h20cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube128hash, 256, 4, 5>
(pub, priv, rng);
}
int algo_fmtseq192h20cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube192hash, 384, 4, 5>
(pub, priv, rng);
}
int algo_fmtseq256h20cube::create_keypair (sencode**pub, sencode**priv, prng&rng)
{
return fmtseq_create_keypair<cube256hash, 512, 4, 5>
(pub, priv, rng);
}

136
src/algos_sig.h
View File

@ -153,5 +153,141 @@ public:
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
/*
* Cubehash variants
*/
class algo_fmtseq128cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ128-CUBE256-CUBE128";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq192cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ192-CUBE384-CUBE192";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq256cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ256-CUBE512-CUBE256";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq128h20cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ128H20-CUBE256-CUBE128";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq192h20cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ192H20-CUBE384-CUBE192";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
class algo_fmtseq256h20cube : public algorithm
{
public:
bool provides_signatures() {
return true;
}
bool provides_encryption() {
return false;
}
std::string get_alg_id() {
return "FMTSEQ256H20-CUBE512-CUBE256";
}
virtual int sign (const bvector&msg, bvector&sig,
sencode** privkey, bool&dirty, prng&rng);
virtual int verify (const bvector&sig, const bvector&msg,
sencode* pubkey);
int create_keypair (sencode**pub, sencode**priv, prng&rng);
};
#endif