restructuralization
- removed cfs_qd (I didn't find a workable specification and it's still slow&ugly) - removed mce_oc (it's just insecure and no one will use that) - removed library structure, it isn't neccesary anyway - added primitives for hashing to prepare for FMTseq
This commit is contained in:
parent
17d6a55141
commit
d1fe9b176b
|
|
@ -2,7 +2,7 @@
|
||||||
|
|
||||||
# simple autogen script that generates basic layout for autotools.
|
# simple autogen script that generates basic layout for autotools.
|
||||||
|
|
||||||
COMMON_CPPFLAGS="-I/usr/local/include -I\$(srcdir)/include/"
|
COMMON_CPPFLAGS="-I/usr/local/include"
|
||||||
COMMON_CFLAGS="-Wall"
|
COMMON_CFLAGS="-Wall"
|
||||||
COMMON_LDFLAGS="-L/usr/local/lib"
|
COMMON_LDFLAGS="-L/usr/local/lib"
|
||||||
COMMON_LDADD=""
|
COMMON_LDADD=""
|
||||||
|
|
@ -16,19 +16,14 @@ DISTDIRS=""
|
||||||
echo "AUTOMAKE_OPTIONS = subdir-objects" >>$OUT
|
echo "AUTOMAKE_OPTIONS = subdir-objects" >>$OUT
|
||||||
echo "dist_noinst_SCRIPTS = autogen.sh" `for i in $DISTDIRS ; do find \$i -type f ; done | tr "\n" " " ` >>$OUT
|
echo "dist_noinst_SCRIPTS = autogen.sh" `for i in $DISTDIRS ; do find \$i -type f ; done | tr "\n" " " ` >>$OUT
|
||||||
|
|
||||||
echo "noinst_HEADERS = `find include/ -type f -name \*.h |tr \"\n\" \" \" `" >>$OUT
|
|
||||||
echo "noinst_HEADERS += `find lib/ -type f -name \*.h |tr \"\n\" \" \" `" >>$OUT
|
|
||||||
|
|
||||||
echo "bin_PROGRAMS = ccr" >>$OUT
|
echo "bin_PROGRAMS = ccr" >>$OUT
|
||||||
echo "ccrdir = src/" >>$OUT
|
echo "ccrdir = src/" >>$OUT
|
||||||
echo "ccr_SOURCES = `( find src/ -type f -name \*.c ; find src/ -type f -name \*.cpp ) |tr \"\n\" \" \" ` " >>$OUT
|
echo "ccr_SOURCES = `( find src/ -type f -name \*.c ; find src/ -type f -name \*.cpp ) |tr \"\n\" \" \" ` " >>$OUT
|
||||||
echo "ccr_SOURCES += `(find lib/ -type f -name *.c; find lib/ -type f -name *.cpp)|tr \"\n\" \" \" ` " >>$OUT
|
echo "noinst_HEADERS = `find src/ -type f -name \*.h |tr \"\n\" \" \" `" >>$OUT
|
||||||
echo "noinst_HEADERS += `find src/ -type f -name \*.h |tr \"\n\" \" \" `" >>$OUT
|
|
||||||
echo "ccr_CPPFLAGS = -I\$(srcdir)/$i/ ${COMMON_CPPFLAGS}" >>$OUT
|
echo "ccr_CPPFLAGS = -I\$(srcdir)/$i/ ${COMMON_CPPFLAGS}" >>$OUT
|
||||||
echo "ccr_CFLAGS = ${COMMON_CFLAGS}" >>$OUT
|
echo "ccr_CFLAGS = ${COMMON_CFLAGS}" >>$OUT
|
||||||
echo "ccr_LDFLAGS = ${COMMON_LDFLAGS}" >>$OUT
|
echo "ccr_LDFLAGS = ${COMMON_LDFLAGS}" >>$OUT
|
||||||
echo "ccr_LDADD = -lgmp ${COMMON_LDADD} " >>$OUT
|
echo "ccr_LDADD = -lgmp ${COMMON_LDADD} " >>$OUT
|
||||||
[ -f "src/Makefile.am.extra" ] && cat "src/Makefile.am.extra" >>$OUT
|
|
||||||
|
|
||||||
libtoolize --force && aclocal && autoconf && automake --add-missing
|
libtoolize --force && aclocal && autoconf && automake --add-missing
|
||||||
|
|
||||||
|
|
|
||||||
580
lib/cfs_qd.cpp
580
lib/cfs_qd.cpp
|
|
@ -1,580 +0,0 @@
|
||||||
|
|
||||||
/*
|
|
||||||
* This file is part of Codecrypt.
|
|
||||||
*
|
|
||||||
* Codecrypt is free software: you can redistribute it and/or modify it
|
|
||||||
* under the terms of the GNU Lesser General Public License as published by
|
|
||||||
* the Free Software Foundation, either version 3 of the License, or (at
|
|
||||||
* your option) any later version.
|
|
||||||
*
|
|
||||||
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
|
||||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
||||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
||||||
* License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU Lesser General Public License
|
|
||||||
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "codecrypt.h"
|
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
using namespace ccr::cfs_qd;
|
|
||||||
|
|
||||||
#include "decoding.h"
|
|
||||||
#include "qd_utils.h"
|
|
||||||
|
|
||||||
#include <set>
|
|
||||||
|
|
||||||
int cfs_qd::generate (pubkey&pub, privkey&priv, prng&rng,
|
|
||||||
uint m, uint T, uint t, uint block_discard)
|
|
||||||
{
|
|
||||||
priv.fld.create (m);
|
|
||||||
priv.T = T;
|
|
||||||
uint block_size = 1 << T;
|
|
||||||
if (t > block_size) return 2;
|
|
||||||
priv.t = t;
|
|
||||||
|
|
||||||
//convenience
|
|
||||||
gf2m&fld = priv.fld;
|
|
||||||
std::vector<uint>&essence = priv.essence;
|
|
||||||
|
|
||||||
std::vector<uint> support, Hsig;
|
|
||||||
polynomial g;
|
|
||||||
uint i, j;
|
|
||||||
|
|
||||||
//prepare for data
|
|
||||||
Hsig.resize (fld.n);
|
|
||||||
support.resize (fld.n);
|
|
||||||
essence.resize (m + 1);
|
|
||||||
//note that q=2^m, algo. n=q/2, log n = m-1
|
|
||||||
|
|
||||||
//retry generating until goppa code is produced.
|
|
||||||
for (;;) {
|
|
||||||
|
|
||||||
std::cout << "attempt" << std::endl;
|
|
||||||
|
|
||||||
std::set<uint> used;
|
|
||||||
used.clear();
|
|
||||||
|
|
||||||
//first off, compute the H signature
|
|
||||||
|
|
||||||
Hsig[0] = choose_random (fld.n, rng, used);
|
|
||||||
essence[m] = fld.inv (Hsig[0]);
|
|
||||||
//essence[m] is now used as precomputed 1/h_0
|
|
||||||
|
|
||||||
for (uint s = 0; s < m; ++s) {
|
|
||||||
i = 1 << s; //i = 2^s
|
|
||||||
|
|
||||||
Hsig[i] = choose_random (fld.n, rng, used);
|
|
||||||
essence[s] = fld.add (essence[m], fld.inv (Hsig[i]) );
|
|
||||||
used.insert (fld.inv (essence[s]) );
|
|
||||||
|
|
||||||
for (j = 1; j < i; ++j) {
|
|
||||||
uint hij = fld.inv
|
|
||||||
(fld.add
|
|
||||||
(fld.inv (Hsig[i]),
|
|
||||||
fld.add (
|
|
||||||
fld.inv (Hsig[j]),
|
|
||||||
essence[m]
|
|
||||||
) ) );
|
|
||||||
if ( (!Hsig[i]) || (!Hsig[j]) ) hij = 0;
|
|
||||||
Hsig[i + j] = hij;
|
|
||||||
if (hij) {
|
|
||||||
used.insert (Hsig[i + j]);
|
|
||||||
/*used.insert (fld.inv
|
|
||||||
(fld.add
|
|
||||||
(fld.inv (Hsig[i + j]),
|
|
||||||
essence[m]) ) );*/
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "Gen Hsig: ";
|
|
||||||
for (i = 0; i < fld.n; ++i) std::cout << Hsig[i] << ' ';
|
|
||||||
std::cout << std::endl;
|
|
||||||
|
|
||||||
//let's play with blocks.
|
|
||||||
uint block_size = 1 << T,
|
|
||||||
h_block_count = fld.n / block_size,
|
|
||||||
block_count = h_block_count - block_discard;
|
|
||||||
|
|
||||||
//check if we have enough good blocks.
|
|
||||||
std::vector<bool> block_status;
|
|
||||||
uint badblocks;
|
|
||||||
block_status.resize (h_block_count);
|
|
||||||
|
|
||||||
badblocks = 0;
|
|
||||||
for (i = 0; i < h_block_count; ++i) {
|
|
||||||
block_status[i] = true;
|
|
||||||
for (j = 0; j < block_size; ++j)
|
|
||||||
if (!Hsig[i * block_size + j]) {
|
|
||||||
block_status[i] = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if (!block_status[i]) ++badblocks;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "badblocks: " << badblocks << std::endl;
|
|
||||||
|
|
||||||
if (badblocks > block_discard) continue; //don't have enough good blocks
|
|
||||||
if (!block_status[0]) continue; //cannot assemble goppa poly
|
|
||||||
|
|
||||||
std::cout << "lol contd." << std::endl;
|
|
||||||
|
|
||||||
//reconstruct g
|
|
||||||
used.clear();
|
|
||||||
g.clear();
|
|
||||||
g.resize (1, 1); //g(x)=1 so we can multiply it
|
|
||||||
polynomial tmp;
|
|
||||||
tmp.resize (2, 1); //tmp(x)=x-1
|
|
||||||
bool consistent = true;
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
//tmp(x)=x-z=x-(1/h_i) where h_i is squared!
|
|
||||||
tmp[0] = fld.inv (Hsig[i]);
|
|
||||||
if (used.count (tmp[0]) ) {
|
|
||||||
consistent = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
used.insert (tmp[0]);
|
|
||||||
g.mult (tmp, fld);
|
|
||||||
}
|
|
||||||
if (!consistent) continue; //retry
|
|
||||||
|
|
||||||
std::cout << "lol have g: " << g;
|
|
||||||
|
|
||||||
//compute the support, retry if it has two equal elements.
|
|
||||||
for (i = 0; i < fld.n; ++i) {
|
|
||||||
if (!block_status[i / block_size]) continue;
|
|
||||||
support[i] = fld.add (
|
|
||||||
fld.inv (Hsig[i]),
|
|
||||||
essence[m]);
|
|
||||||
|
|
||||||
std::cout << "support " << i << " = " << support[i] << std::endl;
|
|
||||||
if (used.count (support[i]) ) {
|
|
||||||
std::cout << "support inconsistent at " << i << std::endl;
|
|
||||||
++badblocks;
|
|
||||||
block_status[i / block_size] = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
used.insert (support[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "bad: " << badblocks << std::endl;
|
|
||||||
if (badblocks > block_discard) continue;
|
|
||||||
|
|
||||||
//assemble blocks to bl
|
|
||||||
std::vector<polynomial> bl, blp;
|
|
||||||
bl.resize (h_block_count);
|
|
||||||
for (i = 0; i < h_block_count; ++i) {
|
|
||||||
bl[i].resize (block_size);
|
|
||||||
for (j = 0; j < block_size; ++j)
|
|
||||||
bl[i][j] = Hsig[i * block_size + j];
|
|
||||||
}
|
|
||||||
|
|
||||||
//permute the blocks. first move the damaged to discard area
|
|
||||||
priv.block_perm.generate_identity (h_block_count);
|
|
||||||
uint oks = h_block_count;
|
|
||||||
for (i = 0; i < oks; ++i)
|
|
||||||
if (!block_status[i]) {
|
|
||||||
std::cout << "removing one" << std::endl;
|
|
||||||
--oks;
|
|
||||||
priv.block_perm[i] = oks;
|
|
||||||
priv.block_perm[oks] = i;
|
|
||||||
//swap block statuses as well
|
|
||||||
bool tmp = block_status[i];
|
|
||||||
block_status[i] = block_status[oks];
|
|
||||||
block_status[oks] = tmp;
|
|
||||||
--i;
|
|
||||||
}
|
|
||||||
std::cout << "BLOCK " << priv.block_perm;
|
|
||||||
permutation rest_perm;
|
|
||||||
rest_perm.generate_random (oks, rng);
|
|
||||||
//permute the undamaged part of block_perm by hand TODO FIXME
|
|
||||||
//for (i = 0; i < oks; ++i) rest_perm[i] = priv.block_perm[rest_perm[i]];
|
|
||||||
//for (i = 0; i < oks; ++i) priv.block_perm[i] = rest_perm[i];
|
|
||||||
|
|
||||||
//now we can safely permute and discard blocks
|
|
||||||
priv.block_perm.permute (bl, blp);
|
|
||||||
blp.resize (block_count);
|
|
||||||
|
|
||||||
//permute individual blocks
|
|
||||||
priv.block_perms.resize (block_count);
|
|
||||||
bl.resize (blp.size() );
|
|
||||||
for (i = 0; i < block_count; ++i) {
|
|
||||||
priv.block_perms[i] = rng.random (block_size);
|
|
||||||
permutation::permute_dyadic (priv.block_perms[i],
|
|
||||||
blp[i], bl[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
//construct H
|
|
||||||
pub.qd_sigs.resize (fld.m);
|
|
||||||
bvector col;
|
|
||||||
bvector block;
|
|
||||||
for (i = 0; i < fld.m; ++i)
|
|
||||||
pub.qd_sigs[i].resize (block_count * block_size);
|
|
||||||
for (i = 0; i < block_count; ++i) {
|
|
||||||
col.from_poly_cotrace (bl[i], fld);
|
|
||||||
for (j = 0; j < fld.m; ++j) {
|
|
||||||
col.get_block (j * block_size,
|
|
||||||
block_size, block);
|
|
||||||
|
|
||||||
pub.qd_sigs[j].set_block
|
|
||||||
(block, block_size * i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//finish the pubkey
|
|
||||||
pub.T = T;
|
|
||||||
pub.t = t;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int privkey::prepare()
|
|
||||||
{
|
|
||||||
uint s, i, j, k;
|
|
||||||
std::vector<uint> Hsig, support;
|
|
||||||
uint omega;
|
|
||||||
|
|
||||||
uint block_count = block_perms.size(),
|
|
||||||
block_size = 1 << T;
|
|
||||||
|
|
||||||
//compute H signature from essence
|
|
||||||
Hsig.resize (fld.n);
|
|
||||||
Hsig[0] = fld.inv (essence[fld.m]);
|
|
||||||
for (s = 0; s < fld.m; ++s) {
|
|
||||||
i = 1 << s; //i = 2^s
|
|
||||||
|
|
||||||
Hsig[i] = fld.inv (fld.add (essence[s], essence[fld.m]) );
|
|
||||||
|
|
||||||
for (j = 1; j < i; ++j)
|
|
||||||
Hsig[i + j] = fld.inv
|
|
||||||
(fld.add
|
|
||||||
(fld.inv (Hsig[i]),
|
|
||||||
fld.add (
|
|
||||||
fld.inv (Hsig[j]),
|
|
||||||
essence[fld.m]
|
|
||||||
) ) );
|
|
||||||
}
|
|
||||||
std::cout << "Gen Hsig: ";
|
|
||||||
for (i = 0; i < fld.n; ++i) std::cout << Hsig[i] << ' ';
|
|
||||||
std::cout << std::endl;
|
|
||||||
|
|
||||||
|
|
||||||
//goppa polynomial with omega=0
|
|
||||||
std::set<uint> used;
|
|
||||||
used.clear();
|
|
||||||
|
|
||||||
polynomial tmp;
|
|
||||||
g.clear();
|
|
||||||
g.resize (1, 1); //g(x)=1
|
|
||||||
tmp.clear();
|
|
||||||
tmp.resize (2, 1); //tmp(x)=x+1
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
tmp[0] = fld.inv (Hsig[i]); //tmp(x)=x+1/h_i
|
|
||||||
if (used.count (tmp[0]) )
|
|
||||||
return 1;
|
|
||||||
std::cout << tmp[0] << std::endl;
|
|
||||||
used.insert (tmp[0]);
|
|
||||||
g.mult (tmp, fld);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "HERE 1" << std::endl;
|
|
||||||
//compute the support with omega=0
|
|
||||||
support.resize (fld.n);
|
|
||||||
for (i = 0; i < fld.n; ++i) {
|
|
||||||
//don't compute with discarded support
|
|
||||||
if (block_perm[i / block_size] >= block_count) continue;
|
|
||||||
support[i] = fld.add
|
|
||||||
(fld.inv (Hsig[i]),
|
|
||||||
essence[fld.m]);
|
|
||||||
std::cout << "support " << i << " = " << support[i] << std::endl;
|
|
||||||
if (used.count (support[i]) ) //invalid support
|
|
||||||
return 1;
|
|
||||||
used.insert (support[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "HERE LOLOLOLOLOL" << std::endl;
|
|
||||||
//choose omega
|
|
||||||
omega = fld.n;
|
|
||||||
for (i = 0; i < fld.n; ++i)
|
|
||||||
if (!used.count (i) ) {
|
|
||||||
omega = i;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if (omega == fld.n) return 1;
|
|
||||||
|
|
||||||
//modify support to omega-ized version
|
|
||||||
for (i = 0; i < support.size(); ++i)
|
|
||||||
support[i] = fld.add (support[i], omega);
|
|
||||||
|
|
||||||
//modify g to omega-ized version
|
|
||||||
g.clear();
|
|
||||||
tmp.clear();
|
|
||||||
g.resize (1, 1); //g(x)=1
|
|
||||||
tmp.resize (2, 1); //tmp(x)=x+1
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
tmp[0] = fld.add (fld.inv (Hsig[i]), omega);
|
|
||||||
g.mult (tmp, fld);
|
|
||||||
}
|
|
||||||
|
|
||||||
g.compute_square_root_matrix (sqInv, fld);
|
|
||||||
|
|
||||||
// prepare permuted support, from that prepare permuted check matrix
|
|
||||||
// (so that it can be applied directly)
|
|
||||||
uint pos;
|
|
||||||
std::vector<uint> sbl1, sbl2, permuted_support;
|
|
||||||
|
|
||||||
sbl1.resize (block_size);
|
|
||||||
sbl2.resize (block_size);
|
|
||||||
permuted_support.resize (block_size * block_count);
|
|
||||||
|
|
||||||
//permute support
|
|
||||||
for (i = 0; i < fld.n / block_size; ++i) {
|
|
||||||
pos = block_perm[i];
|
|
||||||
if (pos >= block_count) continue; //was discarded
|
|
||||||
|
|
||||||
//permute i-th block of support
|
|
||||||
for (j = 0; j < block_size; ++j)
|
|
||||||
sbl1[j] = support[j + i * block_size];
|
|
||||||
|
|
||||||
permutation::permute_dyadic (block_perms[pos], sbl1, sbl2);
|
|
||||||
|
|
||||||
//store support to permuted support
|
|
||||||
for (j = 0; j < block_size; ++j)
|
|
||||||
permuted_support[j + pos * block_size] = sbl2[j];
|
|
||||||
}
|
|
||||||
|
|
||||||
//convert the permuted support to actual lookup
|
|
||||||
support_pos.clear();
|
|
||||||
//fld.n in support lookup means that it isn't there (we don't have -1)
|
|
||||||
support_pos.resize (fld.n, fld.n);
|
|
||||||
for (i = 0; i < block_size * block_count; ++i)
|
|
||||||
support_pos[permuted_support[i]] = i;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* TODO move this to separate function
|
|
||||||
*
|
|
||||||
* prepare the matrix to compute decodable syndrome from QD matrix. From Barreto's slides:
|
|
||||||
*
|
|
||||||
* A is public check matrix
|
|
||||||
* H is private check matrix producing decodable syndromes
|
|
||||||
*
|
|
||||||
* H=SA for some S
|
|
||||||
* therefore if
|
|
||||||
*
|
|
||||||
* synd = A * codeword
|
|
||||||
*
|
|
||||||
* then
|
|
||||||
*
|
|
||||||
* S*synd = H*codeword
|
|
||||||
*
|
|
||||||
* and S = H * A^T * (A * A^T)^-1
|
|
||||||
*/
|
|
||||||
|
|
||||||
std::vector<std::vector<uint> > ma, mb, tmpa, tmph;
|
|
||||||
std::vector<uint> t1, t2;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* First, precompute the matrices A and H
|
|
||||||
*/
|
|
||||||
|
|
||||||
tmpa.resize (t);
|
|
||||||
tmph.resize (t);
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
tmpa[i].resize (fld.n);
|
|
||||||
tmph[i].resize (fld.n);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < t; ++i)
|
|
||||||
permutation::permute_dyadic (i, Hsig, tmpa[i]);
|
|
||||||
|
|
||||||
std::cout << "TMPA" << std::endl;
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
for (j = 0; j < fld.n; ++j) std::cout << tmpa[i][j] << ' ';
|
|
||||||
std::cout << std::endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
polynomial tmpcol;
|
|
||||||
for (i = 0; i < fld.n; ++i) {
|
|
||||||
tmpcol.resize (2);
|
|
||||||
tmpcol[0] = support[i];
|
|
||||||
tmpcol[1] = 1;
|
|
||||||
tmpcol.inv (g, fld);
|
|
||||||
tmpcol.resize (t, 0);
|
|
||||||
for (j = 0; j < t; ++j) tmph[j][i] = tmpcol[j];
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* compute H * H^T to ma and A * H^T to mb.
|
|
||||||
*/
|
|
||||||
|
|
||||||
ma.resize (t);
|
|
||||||
mb.resize (t);
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
ma[i].resize (t, 0);
|
|
||||||
mb[i].resize (t, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < t; ++i) for (j = 0; j < t; ++j) {
|
|
||||||
for (k = 0; k < fld.n; ++k) {
|
|
||||||
ma[i][j] = fld.add (ma[i][j], fld.mult (tmph[i][k], tmph[j][k]) );
|
|
||||||
mb[i][j] = fld.add (mb[i][j], fld.mult (tmpa[i][k], tmph[j][k]) );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "MA" << std::endl;
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
for (j = 0; j < t; ++j) std::cout << ma[i][j] << ' ';
|
|
||||||
std::cout << std::endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "MB" << std::endl;
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
for (j = 0; j < t; ++j) std::cout << mb[i][j] << ' ';
|
|
||||||
std::cout << std::endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* now invert mb into ma as (mb|ma) to (I|ma*mb^-1)
|
|
||||||
*
|
|
||||||
* (result will be transposed, but that's actually good for our purpose)
|
|
||||||
*/
|
|
||||||
|
|
||||||
uint x;
|
|
||||||
//gauss step
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
//find pivot
|
|
||||||
for (j = i; j < t; ++j) if (mb[j][i] != 0) break;
|
|
||||||
if (j >= t) return 1; //no pivot -> not invertible
|
|
||||||
if (j > i) {
|
|
||||||
ma[j].swap (ma[i]);
|
|
||||||
mb[j].swap (mb[i]);
|
|
||||||
}
|
|
||||||
//normalize
|
|
||||||
x = fld.inv (mb[i][i]);
|
|
||||||
for (j = 0; j < t; ++j) {
|
|
||||||
ma[i][j] = fld.mult (ma[i][j], x);
|
|
||||||
mb[i][j] = fld.mult (mb[i][j], x);
|
|
||||||
}
|
|
||||||
//zero rows below
|
|
||||||
for (j = i + 1; j < t; ++j) {
|
|
||||||
x = mb[j][i];
|
|
||||||
if (x == 0) continue;
|
|
||||||
for (k = 0; k < t; ++k) {
|
|
||||||
ma[j][k] = fld.add (ma[j][k], fld.mult (x, ma[i][k]) );
|
|
||||||
mb[j][k] = fld.add (mb[j][k], fld.mult (x, mb[i][k]) );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//jordan step
|
|
||||||
std::cout << "jordan step..." << std::endl;
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
for (j = i + 1; j < t; ++j) {
|
|
||||||
x = mb[t - j - 1][t - i - 1];
|
|
||||||
if (x == 0) continue;
|
|
||||||
for (k = 0; k < t; ++k) {
|
|
||||||
ma[t - j - 1][k] = fld.add (ma[t - j - 1][k], fld.mult (x, ma[t - i - 1][k]) );
|
|
||||||
mb[t - j - 1][k] = fld.add (mb[t - j - 1][k], fld.mult (x, mb[t - i - 1][k]) );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//result is now transposed in ma.
|
|
||||||
syndS.resize (t);
|
|
||||||
for (i = 0; i < t; ++i) {
|
|
||||||
syndS[i].resize (t);
|
|
||||||
for (j = 0; j < t; ++j) syndS[i][j] = ma[i][j];
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "SyndS is OKAY!" << std::endl;
|
|
||||||
|
|
||||||
polynomial decsynd, loc;
|
|
||||||
for (i = 0; i < t; ++i)
|
|
||||||
decsynd.add_mult (syndS[i], Hsig[i], fld);
|
|
||||||
compute_goppa_error_locator (decsynd, fld, g, sqInv, loc);
|
|
||||||
std::cout << "TEST LOCATOR: " << loc;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int privkey::sign (const bvector& hash, bvector&signature,
|
|
||||||
uint delta, uint attempts, prng&rng)
|
|
||||||
{
|
|
||||||
if (hash.size() != hash_size() ) return 2;
|
|
||||||
|
|
||||||
polynomial synd, decsynd, tmp, loc;
|
|
||||||
bvector ev, h2;
|
|
||||||
|
|
||||||
uint i;
|
|
||||||
|
|
||||||
for (uint att = 0; att < attempts; ++att) {
|
|
||||||
h2 = hash;
|
|
||||||
for (i = 0; i < delta; ++i) {
|
|
||||||
uint p = rng.random (h2.size() );
|
|
||||||
h2[p] = !h2[p];
|
|
||||||
}
|
|
||||||
|
|
||||||
h2.to_poly_cotrace (synd, fld);
|
|
||||||
|
|
||||||
std::cout << "SYND" << synd;
|
|
||||||
|
|
||||||
decsynd.clear();
|
|
||||||
for (i = 0; i < t; ++i)
|
|
||||||
decsynd.add_mult (syndS[i], synd[i], fld);
|
|
||||||
|
|
||||||
std::cout << "SYND PREP" << decsynd;
|
|
||||||
|
|
||||||
compute_goppa_error_locator (decsynd, fld, g, sqInv, loc);
|
|
||||||
if (!evaluate_error_locator_trace (loc, ev, fld) ) continue;
|
|
||||||
//we might have it!
|
|
||||||
std::cout << ev;
|
|
||||||
signature.clear();
|
|
||||||
signature.resize (signature_size(), 0);
|
|
||||||
|
|
||||||
for (i = 0; i < fld.n; ++i) if (ev[i]) {
|
|
||||||
uint epos = support_pos[i];
|
|
||||||
if (epos == fld.n) break; //bad luck, undecodable
|
|
||||||
signature[epos] = 1;
|
|
||||||
}
|
|
||||||
if (i == fld.n) return 0;
|
|
||||||
}
|
|
||||||
return 1; //no attempts left.
|
|
||||||
}
|
|
||||||
|
|
||||||
int pubkey::verify (const bvector&signature, const bvector&hash, uint delta)
|
|
||||||
{
|
|
||||||
if (signature.size() != signature_size() ) return 2;
|
|
||||||
if (hash.size() != hash_size() ) return 2;
|
|
||||||
|
|
||||||
uint i, j;
|
|
||||||
uint block_size = 1 << T;
|
|
||||||
bvector synd, b1, b2;
|
|
||||||
|
|
||||||
synd.resize (t * qd_sigs.size(), 0);
|
|
||||||
//compute the syndrome
|
|
||||||
for (i = 0; i < signature_size(); ++i) {
|
|
||||||
if (!signature[i]) continue;
|
|
||||||
|
|
||||||
//this is actually quite fast, as it happens only several times
|
|
||||||
for (j = 0; j < qd_sigs.size(); ++j) {
|
|
||||||
qd_sigs[j].get_block ( (i / block_size) *block_size,
|
|
||||||
block_size, b1);
|
|
||||||
permutation::permute_dyadic (i % block_size, b1, b2);
|
|
||||||
b2.resize (t);
|
|
||||||
synd.add_offset (b2, t * j);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
std::cout << "SYNDROME: " << synd;
|
|
||||||
synd.add (hash);
|
|
||||||
std::cout << "DIFF: " << synd;
|
|
||||||
if (synd.hamming_weight() > delta) return 1;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
185
lib/mce_oc.cpp
185
lib/mce_oc.cpp
|
|
@ -1,185 +0,0 @@
|
||||||
|
|
||||||
/*
|
|
||||||
* This file is part of Codecrypt.
|
|
||||||
*
|
|
||||||
* Codecrypt is free software: you can redistribute it and/or modify it
|
|
||||||
* under the terms of the GNU Lesser General Public License as published by
|
|
||||||
* the Free Software Foundation, either version 3 of the License, or (at
|
|
||||||
* your option) any later version.
|
|
||||||
*
|
|
||||||
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
|
||||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
||||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
||||||
* License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU Lesser General Public License
|
|
||||||
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "codecrypt.h"
|
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
using namespace ccr::mce_oc;
|
|
||||||
|
|
||||||
#include "decoding.h"
|
|
||||||
|
|
||||||
int mce_oc::generate (pubkey&pub, privkey&priv,
|
|
||||||
prng&rng, uint m, uint t, uint n)
|
|
||||||
{
|
|
||||||
priv.fld.create (m);
|
|
||||||
|
|
||||||
uint subplain_size = priv.fld.n - (m * t),
|
|
||||||
codeword_size = (n * subplain_size) + (m * t);
|
|
||||||
|
|
||||||
//prepare resulting generator matrix
|
|
||||||
matrix g;
|
|
||||||
g.resize (codeword_size);
|
|
||||||
for (uint i = 0; i < codeword_size; ++i)
|
|
||||||
g[i].resize (subplain_size * n);
|
|
||||||
|
|
||||||
//generate n subcodes
|
|
||||||
priv.codes.resize (n);
|
|
||||||
for (uint i = 0; i < n; ++i) {
|
|
||||||
privkey::subcode& sc = priv.codes[i];
|
|
||||||
|
|
||||||
sc.g.generate_random_irreducible (t, priv.fld, rng);
|
|
||||||
sc.g.compute_goppa_check_matrix (sc.h, priv.fld);
|
|
||||||
|
|
||||||
matrix subg;
|
|
||||||
while (!sc.h.create_goppa_generator (subg, sc.hperm, rng) );
|
|
||||||
g.set_block (subplain_size * i, subplain_size * i, subg);
|
|
||||||
}
|
|
||||||
|
|
||||||
//scramble matrix
|
|
||||||
matrix S;
|
|
||||||
S.generate_random_with_inversion (g.height(), priv.Sinv, rng);
|
|
||||||
|
|
||||||
//scramble permutation
|
|
||||||
permutation P;
|
|
||||||
P.generate_random (g.width(), rng);
|
|
||||||
P.compute_inversion (priv.Pinv);
|
|
||||||
|
|
||||||
//public key
|
|
||||||
pub.n = n;
|
|
||||||
pub.t = t;
|
|
||||||
S.mult (g);
|
|
||||||
P.permute (S, pub.G);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int privkey::prepare ()
|
|
||||||
{
|
|
||||||
for (uint i = 0; i < codes.size(); ++i) {
|
|
||||||
codes[i].g.compute_goppa_check_matrix (codes[i].h, fld);
|
|
||||||
codes[i].g.compute_square_root_matrix (codes[i].sqInv, fld);
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int privkey::sign (const bvector&in, bvector&out,
|
|
||||||
uint delta, uint attempts, prng&rng)
|
|
||||||
{
|
|
||||||
if (in.size() != hash_size() ) return 2;
|
|
||||||
if (!codes.size() ) return 2;
|
|
||||||
|
|
||||||
//remove permutation
|
|
||||||
bvector inp;
|
|
||||||
Pinv.permute (in, inp);
|
|
||||||
|
|
||||||
//decoding helpers
|
|
||||||
bvector e, e2, synd, synd_orig, cw, cwc, plain, overlap;
|
|
||||||
std::vector<uint> epos;
|
|
||||||
permutation hpermInv;
|
|
||||||
polynomial loc, Synd;
|
|
||||||
uint i, t;
|
|
||||||
|
|
||||||
uint mt = fld.m * codes[0].g.degree(),
|
|
||||||
subplain_size = fld.n - mt;
|
|
||||||
|
|
||||||
plain.clear();
|
|
||||||
|
|
||||||
//decode the rest
|
|
||||||
for (uint ci = 0; ci < codes.size(); ++ci) {
|
|
||||||
|
|
||||||
e.clear();
|
|
||||||
e.resize (fld.n, 0);
|
|
||||||
epos.resize (delta, 0);
|
|
||||||
|
|
||||||
//create the codeword
|
|
||||||
cw.clear();
|
|
||||||
if (ci == 0)
|
|
||||||
cw.insert (cw.end(), inp.begin(), inp.begin() + fld.n);
|
|
||||||
else {
|
|
||||||
cw = overlap;
|
|
||||||
bvector::iterator tmp = inp.begin();
|
|
||||||
tmp += (ci * subplain_size) + mt;
|
|
||||||
cw.insert (cw.end(), tmp, tmp + subplain_size);
|
|
||||||
}
|
|
||||||
|
|
||||||
//create the overlap, xor it to codeword
|
|
||||||
if (ci + 1 < codes.size() ) {
|
|
||||||
overlap.resize (mt);
|
|
||||||
for (uint i = 0; i < mt; ++i) overlap[i] = rng.random (2);
|
|
||||||
cw.add_offset (overlap, subplain_size);
|
|
||||||
}
|
|
||||||
|
|
||||||
//compute syndrome with no extra errors
|
|
||||||
codes[ci].hperm.compute_inversion (hpermInv);
|
|
||||||
hpermInv.permute (cw, cwc); //canonical
|
|
||||||
codes[ci].h.mult_vec_right (cwc, synd_orig);
|
|
||||||
|
|
||||||
for (t = 0; t < attempts; ++t) {
|
|
||||||
|
|
||||||
//compute syndrome with extra errors
|
|
||||||
synd = synd_orig;
|
|
||||||
for (i = 0; i < delta; ++i) {
|
|
||||||
epos[i] = rng.random (fld.n);
|
|
||||||
if (!e[epos[i]])
|
|
||||||
synd.add (codes[ci].h[epos[i]]);
|
|
||||||
e[epos[i]] = 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
synd.to_poly (Synd, fld);
|
|
||||||
compute_goppa_error_locator (Synd, fld,
|
|
||||||
codes[ci].g,
|
|
||||||
codes[ci].sqInv, loc);
|
|
||||||
|
|
||||||
if (evaluate_error_locator_trace (loc, e2, fld) ) {
|
|
||||||
cwc.add (e);
|
|
||||||
cwc.add (e2);
|
|
||||||
|
|
||||||
codes[ci].hperm.permute (cwc, cw);
|
|
||||||
plain.insert (plain.end(), cw.begin(),
|
|
||||||
cw.begin() +
|
|
||||||
(fld.n - (fld.m *
|
|
||||||
codes[ci].g.degree() ) )
|
|
||||||
);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (i = 0; i < delta; ++i) {
|
|
||||||
e[epos[i]] = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (t >= attempts) //decoding failed
|
|
||||||
return 1;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
Sinv.mult_vecT_left (plain, out);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int pubkey::verify (const bvector&in, const bvector&hash, uint delta)
|
|
||||||
{
|
|
||||||
bvector tmp;
|
|
||||||
if (!G.mult_vecT_left (in, tmp) ) return 2; //sizing problem
|
|
||||||
if (hash.size() != tmp.size() ) return 1; //invalid hash size
|
|
||||||
|
|
||||||
tmp.add (hash);
|
|
||||||
if (tmp.hamming_weight() > n * (t + delta) ) return 1; //too far
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
@ -17,7 +17,6 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
uint bvector::hamming_weight()
|
uint bvector::hamming_weight()
|
||||||
{
|
{
|
||||||
|
|
@ -36,9 +36,6 @@
|
||||||
item(size_type n, size_type m) const \
|
item(size_type n, size_type m) const \
|
||||||
{ return (*this)[n][m]; };
|
{ return (*this)[n][m]; };
|
||||||
|
|
||||||
namespace ccr
|
|
||||||
{
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* data serialization format
|
* data serialization format
|
||||||
*/
|
*/
|
||||||
|
|
@ -552,157 +549,14 @@ public:
|
||||||
int generate (pubkey&, privkey&, prng&, uint m, uint T, uint b);
|
int generate (pubkey&, privkey&, prng&, uint m, uint T, uint b);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
|
||||||
* QD-CFS
|
|
||||||
*
|
|
||||||
* according to "Quasi-dyadic CFS signatures" by Baretto, Cayrel, Misoczki,
|
|
||||||
* Niebuhr.
|
|
||||||
*
|
|
||||||
* As always with Niederreiter, hash must be of weight t (=1<<T)
|
|
||||||
*/
|
|
||||||
namespace cfs_qd
|
|
||||||
{
|
|
||||||
class privkey
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
std::vector<uint> essence;
|
|
||||||
gf2m fld; //we fix q=2^fld.m=fld.n, n=q/2
|
|
||||||
uint T, t; //size of blocks is 1<<T, t is error correction capability
|
|
||||||
permutation block_perm; //order of blocks
|
|
||||||
std::vector<uint> block_perms; //dyadic permutations of blocks
|
|
||||||
|
|
||||||
//derivable stuff
|
|
||||||
polynomial g; //goppa
|
|
||||||
std::vector<polynomial> sqInv; //sqroot mod g
|
|
||||||
//pre-permuted positions of support rows
|
|
||||||
std::vector<uint> support_pos;
|
|
||||||
std::vector<polynomial> syndS;
|
|
||||||
|
|
||||||
int sign (const bvector&, bvector&, uint d, uint attempts, prng&);
|
|
||||||
int prepare();
|
|
||||||
|
|
||||||
uint hash_size() {
|
|
||||||
return t * fld.m;
|
|
||||||
}
|
|
||||||
uint signature_size() {
|
|
||||||
return (1 << T) * block_perms.size();
|
|
||||||
}
|
|
||||||
uint signature_weight() {
|
|
||||||
return t;
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* serialize();
|
|
||||||
bool unserialize (sencode*);
|
|
||||||
};
|
|
||||||
|
|
||||||
class pubkey
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
uint t, T;
|
|
||||||
//cols of H
|
|
||||||
std::vector<bvector> qd_sigs;
|
|
||||||
|
|
||||||
int verify (const bvector&, const bvector&, uint);
|
|
||||||
|
|
||||||
uint hash_size() {
|
|
||||||
return t * qd_sigs.size();
|
|
||||||
}
|
|
||||||
uint signature_size() {
|
|
||||||
return qd_sigs[0].size();
|
|
||||||
}
|
|
||||||
uint signature_weight() {
|
|
||||||
return t;
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* serialize();
|
|
||||||
bool unserialize (sencode*);
|
|
||||||
};
|
|
||||||
|
|
||||||
int generate (pubkey&, privkey&, prng&, uint m, uint T, uint t, uint b);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* McEliece on Overlapping Chain of Goppa Codes
|
|
||||||
*
|
|
||||||
* Similar to Hamdi's Chained BCH Codes, but with improvements.
|
|
||||||
*
|
|
||||||
* This is experimental, unverified, probably insecure, but practical scheme
|
|
||||||
* that achieves good speed, probability and non-exponential key size for full
|
|
||||||
* decoding that is needed to produce signatures. Technique is described in
|
|
||||||
* documentation, with some (probably sufficient) notes in source code.
|
|
||||||
*
|
|
||||||
* Note that encryption using this scheme is impossible, as there is only an
|
|
||||||
* extremely tiny probability of successful decoding.
|
|
||||||
*/
|
|
||||||
namespace mce_oc
|
|
||||||
{
|
|
||||||
class privkey
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
matrix Sinv;
|
|
||||||
permutation Pinv;
|
|
||||||
gf2m fld;
|
|
||||||
|
|
||||||
class subcode
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
polynomial g;
|
|
||||||
permutation hperm;
|
|
||||||
|
|
||||||
//derivables
|
|
||||||
matrix h;
|
|
||||||
std::vector<polynomial> sqInv;
|
|
||||||
};
|
|
||||||
|
|
||||||
std::vector<subcode> codes;
|
|
||||||
|
|
||||||
int sign (const bvector&, bvector&, uint, uint, prng&);
|
|
||||||
int prepare();
|
|
||||||
|
|
||||||
uint hash_size() {
|
|
||||||
return Pinv.size();
|
|
||||||
}
|
|
||||||
uint signature_size() {
|
|
||||||
return Sinv.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* serialize();
|
|
||||||
bool unserialize (sencode*);
|
|
||||||
};
|
|
||||||
|
|
||||||
class pubkey
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
matrix G;
|
|
||||||
uint n, t;
|
|
||||||
|
|
||||||
int verify (const bvector&, const bvector&, uint);
|
|
||||||
|
|
||||||
uint hash_size() {
|
|
||||||
return G.width();
|
|
||||||
}
|
|
||||||
uint signature_size() {
|
|
||||||
return G.height();
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* serialize();
|
|
||||||
bool unserialize (sencode*);
|
|
||||||
};
|
|
||||||
|
|
||||||
//n is the number of subcodes used
|
|
||||||
int generate (pubkey&, privkey&, prng&, uint m, uint t, uint n);
|
|
||||||
}
|
|
||||||
|
|
||||||
} //namespace ccr
|
|
||||||
|
|
||||||
//global overload for iostream operators
|
//global overload for iostream operators
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
|
|
||||||
std::ostream& operator<< (std::ostream&o, const ccr::polynomial&);
|
std::ostream& operator<< (std::ostream&o, const polynomial&);
|
||||||
std::ostream& operator<< (std::ostream&o, const ccr::permutation&);
|
std::ostream& operator<< (std::ostream&o, const permutation&);
|
||||||
std::ostream& operator<< (std::ostream&o, const ccr::gf2m&);
|
std::ostream& operator<< (std::ostream&o, const gf2m&);
|
||||||
std::ostream& operator<< (std::ostream&o, const ccr::matrix&);
|
std::ostream& operator<< (std::ostream&o, const matrix&);
|
||||||
std::ostream& operator<< (std::ostream&o, const ccr::bvector&);
|
std::ostream& operator<< (std::ostream&o, const bvector&);
|
||||||
|
|
||||||
|
|
||||||
#endif // _CODECRYPT_H_
|
#endif // _CODECRYPT_H_
|
||||||
|
|
@ -21,8 +21,6 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
void compute_goppa_error_locator (polynomial&syndrome,
|
void compute_goppa_error_locator (polynomial&syndrome,
|
||||||
gf2m&fld,
|
gf2m&fld,
|
||||||
polynomial&goppa,
|
polynomial&goppa,
|
||||||
25
src/encryption.h
Normal file
25
src/encryption.h
Normal file
|
|
@ -0,0 +1,25 @@
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This file is part of Codecrypt.
|
||||||
|
*
|
||||||
|
* Codecrypt is free software: you can redistribute it and/or modify it
|
||||||
|
* under the terms of the GNU Lesser General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or (at
|
||||||
|
* your option) any later version.
|
||||||
|
*
|
||||||
|
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||||
|
* License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU Lesser General Public License
|
||||||
|
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _ccr_hash_h_
|
||||||
|
#define _ccr_hash_h_
|
||||||
|
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
@ -18,8 +18,6 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* helpful stuff for arithmetic in GF(2^m) - polynomials over GF(2).
|
* helpful stuff for arithmetic in GF(2^m) - polynomials over GF(2).
|
||||||
*/
|
*/
|
||||||
46
src/hash.h
Normal file
46
src/hash.h
Normal file
|
|
@ -0,0 +1,46 @@
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This file is part of Codecrypt.
|
||||||
|
*
|
||||||
|
* Codecrypt is free software: you can redistribute it and/or modify it
|
||||||
|
* under the terms of the GNU Lesser General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or (at
|
||||||
|
* your option) any later version.
|
||||||
|
*
|
||||||
|
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||||
|
* License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU Lesser General Public License
|
||||||
|
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _ccr_hash_h_
|
||||||
|
#define _ccr_hash_h_
|
||||||
|
|
||||||
|
/*
|
||||||
|
* hash function templates
|
||||||
|
*
|
||||||
|
* usuable mostly for injection into actual code
|
||||||
|
*/
|
||||||
|
|
||||||
|
class hash {
|
||||||
|
public:
|
||||||
|
hash();
|
||||||
|
virtual ~hash()=0;
|
||||||
|
|
||||||
|
virtual void init()=0;
|
||||||
|
virtual void update(const char*a, size_t len)=0;
|
||||||
|
virtual size_t size()=0;
|
||||||
|
virtual void final(const char*a)=0;
|
||||||
|
};
|
||||||
|
|
||||||
|
class hash_factory {
|
||||||
|
public:
|
||||||
|
hash* create();
|
||||||
|
void free(hash*);
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
@ -20,7 +20,6 @@
|
||||||
|
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
using namespace std;
|
using namespace std;
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
ostream& operator<< (ostream&o, const polynomial& p)
|
ostream& operator<< (ostream&o, const polynomial& p)
|
||||||
{
|
{
|
||||||
23
src/keymgmt.h
Normal file
23
src/keymgmt.h
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This file is part of Codecrypt.
|
||||||
|
*
|
||||||
|
* Codecrypt is free software: you can redistribute it and/or modify it
|
||||||
|
* under the terms of the GNU Lesser General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or (at
|
||||||
|
* your option) any later version.
|
||||||
|
*
|
||||||
|
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||||
|
* License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU Lesser General Public License
|
||||||
|
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _ccr_keys_h_
|
||||||
|
#define _ccr_keys_h_
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
151
src/main.cpp
151
src/main.cpp
|
|
@ -17,14 +17,16 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
#include "arcfour.h"
|
||||||
|
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <time.h>
|
#include <time.h>
|
||||||
|
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
|
#include <iomanip>
|
||||||
using namespace std;
|
using namespace std;
|
||||||
|
|
||||||
class primitiverng : public ccr::prng
|
class primitiverng : public prng
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
uint random (uint n) {
|
uint random (uint n) {
|
||||||
|
|
@ -38,20 +40,150 @@ public:
|
||||||
|
|
||||||
int main()
|
int main()
|
||||||
{
|
{
|
||||||
|
arcfour<unsigned short> c;
|
||||||
|
if (!c.init (10) ) {
|
||||||
|
cout << "haha." << endl;
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
std::vector<unsigned short> k;
|
||||||
|
k.push_back ('K');
|
||||||
|
k.push_back ('e');
|
||||||
|
k.push_back ('y');
|
||||||
|
k.push_back ('l');
|
||||||
|
k.push_back ('o');
|
||||||
|
k.push_back ('l');
|
||||||
|
c.load_key (k);
|
||||||
|
|
||||||
|
for (int i = 0; i < 20; ++i)
|
||||||
|
cout << hex << (int) c.gen() << endl;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
#if 0
|
||||||
|
primitiverng r;
|
||||||
|
r.seed (0);
|
||||||
|
|
||||||
|
mce::pubkey pub, pub2;
|
||||||
|
mce::privkey priv, priv2;
|
||||||
|
mce::generate (pub, priv, r, 6, 2);
|
||||||
|
|
||||||
|
sencode *s;
|
||||||
|
std::cout << priv.Pinv;
|
||||||
|
s = priv.serialize();
|
||||||
|
std::cout << s->encode();
|
||||||
|
if (priv.unserialize (s) )
|
||||||
|
std::cout << priv.Pinv;
|
||||||
|
|
||||||
|
sencode_destroy (s);
|
||||||
|
return 0;
|
||||||
|
sencode_list*x = new sencode_list;
|
||||||
|
x->items.push_back (new sencode_int (1) );
|
||||||
|
x->items.push_back (new sencode_bytes ("ahoj") );
|
||||||
|
std::string tmp = x->encode();
|
||||||
|
std::cout << tmp << std::endl;
|
||||||
|
sencode_destroy (x);
|
||||||
|
sencode*s;
|
||||||
|
sencode_decode (tmp, &s);
|
||||||
|
std::cout << s->encode() << std::endl;
|
||||||
|
sencode_destroy (s);
|
||||||
|
bvector b;
|
||||||
|
b.resize (9);
|
||||||
|
b[0] = 1;
|
||||||
|
b[5] = 1;
|
||||||
|
b[8] = 1;
|
||||||
|
s = b.serialize();
|
||||||
|
b[6] = 1;
|
||||||
|
std::cout << s->encode() << std::endl;
|
||||||
|
if (b.unserialize (s) ) {
|
||||||
|
std::cout << b ;
|
||||||
|
}
|
||||||
|
sencode_destroy (s);
|
||||||
|
return 0;
|
||||||
/* this is just a test, don't mind it */
|
/* this is just a test, don't mind it */
|
||||||
primitiverng r;
|
primitiverng r;
|
||||||
r.seed (0);
|
r.seed (0);
|
||||||
|
|
||||||
ccr::mce_qd::privkey priv;
|
/*
|
||||||
ccr::mce_qd::pubkey pub;
|
mce::privkey priv;
|
||||||
ccr::mce_qd::generate (pub, priv, r, 14, 8, 2);
|
mce::pubkey pub;
|
||||||
|
mce::generate(pub,priv,r,8,7);
|
||||||
|
|
||||||
cout << "cipher size: " << priv.cipher_size() << ' ' << pub.cipher_size() << endl;
|
bvector a,b;
|
||||||
cout << "plain size: " << priv.plain_size() << ' ' << pub.plain_size() << endl;
|
|
||||||
|
a.resize(priv.hash_size(),0);
|
||||||
|
|
||||||
|
a[0]=1;
|
||||||
|
a[2]=1;
|
||||||
|
a[4]=1;
|
||||||
|
a[5]=1;
|
||||||
|
a[6]=1;
|
||||||
|
a[7]=1;
|
||||||
|
a[10]=1;
|
||||||
|
a[12]=1;
|
||||||
|
a[16]=1;
|
||||||
|
a[20]=1;
|
||||||
|
a[22]=1;
|
||||||
|
a[24]=1;
|
||||||
|
a[25]=1;
|
||||||
|
a[26]=1;
|
||||||
|
a[27]=1;
|
||||||
|
a[110]=1;
|
||||||
|
a[112]=1;
|
||||||
|
a[116]=1;
|
||||||
|
priv.prepare();
|
||||||
|
priv.sign(a,b,3,10000,r);
|
||||||
|
std::cout << a << b << pub.verify(b,a,3) << std::endl;
|
||||||
|
*/
|
||||||
|
cfs_qd::privkey priv;
|
||||||
|
cfs_qd::pubkey pub;
|
||||||
|
cfs_qd::generate (pub, priv, r, 7, 3, 7, 1);
|
||||||
|
|
||||||
|
cout << "hash size: " << priv.hash_size() << ' ' << pub.hash_size() << endl;
|
||||||
|
cout << "signature size: " << priv.signature_size() << ' ' << pub.signature_size() << endl;
|
||||||
|
|
||||||
|
cout << "sig weight: " << priv.signature_weight() << ' ' << pub.signature_weight() << endl;
|
||||||
|
|
||||||
priv.prepare();
|
priv.prepare();
|
||||||
|
|
||||||
ccr::bvector plain;
|
bvector hash;
|
||||||
|
hash.resize (priv.hash_size(), 0);
|
||||||
|
hash[0] = 1;
|
||||||
|
hash[2] = 1;
|
||||||
|
hash[4] = 1;
|
||||||
|
hash[5] = 1;
|
||||||
|
hash[6] = 1;
|
||||||
|
hash[7] = 1;
|
||||||
|
hash[10] = 1;
|
||||||
|
hash[12] = 1;
|
||||||
|
hash[16] = 1;
|
||||||
|
hash[20] = 1;
|
||||||
|
hash[22] = 1;
|
||||||
|
hash[24] = 1;
|
||||||
|
hash[25] = 1;
|
||||||
|
hash[26] = 1;
|
||||||
|
hash[27] = 1;
|
||||||
|
hash[110] = 1;
|
||||||
|
hash[112] = 1;
|
||||||
|
hash[116] = 1;
|
||||||
|
|
||||||
|
cout << "HASH " << endl;
|
||||||
|
cout << hash;
|
||||||
|
|
||||||
|
bvector sig;
|
||||||
|
if (priv.sign (hash, sig, 3, 10000, r) ) {
|
||||||
|
cout << "failed" << endl;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
cout << "SIGNATURE " << sig;
|
||||||
|
|
||||||
|
if (pub.verify (sig, hash, 3) )
|
||||||
|
cout << "verify failed" << endl;
|
||||||
|
else cout << "verify okay" << endl;
|
||||||
|
|
||||||
|
#endif
|
||||||
|
#if 0
|
||||||
|
bvector plain;
|
||||||
plain.resize (pub.plain_size(), 0);
|
plain.resize (pub.plain_size(), 0);
|
||||||
plain[0] = 1;
|
plain[0] = 1;
|
||||||
plain[1] = 1;
|
plain[1] = 1;
|
||||||
|
|
@ -60,18 +192,19 @@ int main()
|
||||||
cout << "PLAINTEXT" << endl;
|
cout << "PLAINTEXT" << endl;
|
||||||
cout << plain;
|
cout << plain;
|
||||||
|
|
||||||
ccr::bvector cipher;
|
bvector cipher;
|
||||||
pub.encrypt (plain, cipher, r);
|
pub.encrypt (plain, cipher, r);
|
||||||
|
|
||||||
cout << "CIPHERTEXT" << endl;
|
cout << "CIPHERTEXT" << endl;
|
||||||
cout << cipher;
|
cout << cipher;
|
||||||
|
|
||||||
ccr::bvector decrypted;
|
bvector decrypted;
|
||||||
priv.decrypt (cipher, decrypted);
|
priv.decrypt (cipher, decrypted);
|
||||||
|
|
||||||
cout << "DECRYPTED" << endl;
|
cout << "DECRYPTED" << endl;
|
||||||
cout << decrypted;
|
cout << decrypted;
|
||||||
|
|
||||||
|
#endif
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -18,8 +18,6 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
void matrix::resize2 (uint w, uint h, bool def)
|
void matrix::resize2 (uint w, uint h, bool def)
|
||||||
{
|
{
|
||||||
resize (w);
|
resize (w);
|
||||||
|
|
@ -18,8 +18,7 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
using namespace mce;
|
||||||
using namespace ccr::mce;
|
|
||||||
|
|
||||||
#include "decoding.h"
|
#include "decoding.h"
|
||||||
|
|
||||||
|
|
@ -18,8 +18,7 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
using namespace mce_qd;
|
||||||
using namespace ccr::mce_qd;
|
|
||||||
|
|
||||||
#include "decoding.h"
|
#include "decoding.h"
|
||||||
#include "qd_utils.h"
|
#include "qd_utils.h"
|
||||||
23
src/message.h
Normal file
23
src/message.h
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This file is part of Codecrypt.
|
||||||
|
*
|
||||||
|
* Codecrypt is free software: you can redistribute it and/or modify it
|
||||||
|
* under the terms of the GNU Lesser General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or (at
|
||||||
|
* your option) any later version.
|
||||||
|
*
|
||||||
|
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||||
|
* License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU Lesser General Public License
|
||||||
|
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _ccr_msg_h_
|
||||||
|
#define _ccr_msg_h_
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
@ -18,10 +18,9 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
#include "decoding.h"
|
using namespace nd;
|
||||||
|
|
||||||
using namespace ccr;
|
#include "decoding.h"
|
||||||
using namespace ccr::nd;
|
|
||||||
|
|
||||||
int nd::generate (pubkey&pub, privkey&priv, prng&rng, uint m, uint t)
|
int nd::generate (pubkey&pub, privkey&priv, prng&rng, uint m, uint t)
|
||||||
{
|
{
|
||||||
|
|
@ -18,8 +18,6 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
void permutation::compute_inversion (permutation&r) const
|
void permutation::compute_inversion (permutation&r) const
|
||||||
{
|
{
|
||||||
r.resize (size(), 0);
|
r.resize (size(), 0);
|
||||||
|
|
@ -18,8 +18,6 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
int polynomial::degree() const
|
int polynomial::degree() const
|
||||||
{
|
{
|
||||||
int r = -1;
|
int r = -1;
|
||||||
|
|
@ -22,8 +22,6 @@
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
#include <set>
|
#include <set>
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
//FWHT matrix mult in O(n log n). parameters MUST be of 2^m size.
|
//FWHT matrix mult in O(n log n). parameters MUST be of 2^m size.
|
||||||
void fwht_dyadic_multiply (const bvector&, const bvector&, bvector&);
|
void fwht_dyadic_multiply (const bvector&, const bvector&, bvector&);
|
||||||
|
|
||||||
|
|
@ -17,7 +17,6 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
#include <sstream>
|
#include <sstream>
|
||||||
#include <list>
|
#include <list>
|
||||||
|
|
@ -66,7 +65,7 @@ fail:
|
||||||
pos = -1;
|
pos = -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool ccr::sencode_decode (const std::string& str, sencode**out)
|
bool sencode_decode (const std::string& str, sencode**out)
|
||||||
{
|
{
|
||||||
std::list<sencode*> stk;
|
std::list<sencode*> stk;
|
||||||
int pos = 0;
|
int pos = 0;
|
||||||
|
|
@ -125,7 +124,7 @@ bool ccr::sencode_decode (const std::string& str, sencode**out)
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
void ccr::sencode_destroy (sencode*x)
|
void sencode_destroy (sencode*x)
|
||||||
{
|
{
|
||||||
x->destroy();
|
x->destroy();
|
||||||
delete x;
|
delete x;
|
||||||
|
|
@ -18,8 +18,6 @@
|
||||||
|
|
||||||
#include "codecrypt.h"
|
#include "codecrypt.h"
|
||||||
|
|
||||||
using namespace ccr;
|
|
||||||
|
|
||||||
static sencode* serialize_uint_vector (std::vector<uint>*v)
|
static sencode* serialize_uint_vector (std::vector<uint>*v)
|
||||||
{
|
{
|
||||||
sencode_list*l = new sencode_list;
|
sencode_list*l = new sencode_list;
|
||||||
|
|
@ -299,43 +297,3 @@ bool mce_qd::pubkey::unserialize (sencode* s)
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
sencode* cfs_qd::privkey::serialize()
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
bool cfs_qd::privkey::unserialize (sencode* s)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* cfs_qd::pubkey::serialize()
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
bool cfs_qd::pubkey::unserialize (sencode* s)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* mce_oc::privkey::serialize()
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
bool mce_oc::privkey::unserialize (sencode* s)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
sencode* mce_oc::pubkey::serialize()
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
bool mce_oc::pubkey::unserialize (sencode* s)
|
|
||||||
{
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
1065
src/sha2.c
Normal file
1065
src/sha2.c
Normal file
File diff suppressed because it is too large
Load diff
197
src/sha2.h
Normal file
197
src/sha2.h
Normal file
|
|
@ -0,0 +1,197 @@
|
||||||
|
/*
|
||||||
|
* FILE: sha2.h
|
||||||
|
* AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/
|
||||||
|
*
|
||||||
|
* Copyright (c) 2000-2001, Aaron D. Gifford
|
||||||
|
* All rights reserved.
|
||||||
|
*
|
||||||
|
* Redistribution and use in source and binary forms, with or without
|
||||||
|
* modification, are permitted provided that the following conditions
|
||||||
|
* are met:
|
||||||
|
* 1. Redistributions of source code must retain the above copyright
|
||||||
|
* notice, this list of conditions and the following disclaimer.
|
||||||
|
* 2. Redistributions in binary form must reproduce the above copyright
|
||||||
|
* notice, this list of conditions and the following disclaimer in the
|
||||||
|
* documentation and/or other materials provided with the distribution.
|
||||||
|
* 3. Neither the name of the copyright holder nor the names of contributors
|
||||||
|
* may be used to endorse or promote products derived from this software
|
||||||
|
* without specific prior written permission.
|
||||||
|
*
|
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
|
||||||
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
|
||||||
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||||
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||||
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||||
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||||
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||||
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||||
|
* SUCH DAMAGE.
|
||||||
|
*
|
||||||
|
* $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __SHA2_H__
|
||||||
|
#define __SHA2_H__
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Import u_intXX_t size_t type definitions from system headers. You
|
||||||
|
* may need to change this, or define these things yourself in this
|
||||||
|
* file.
|
||||||
|
*/
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
|
#ifdef SHA2_USE_INTTYPES_H
|
||||||
|
|
||||||
|
#include <inttypes.h>
|
||||||
|
|
||||||
|
#endif /* SHA2_USE_INTTYPES_H */
|
||||||
|
|
||||||
|
|
||||||
|
/*** SHA-256/384/512 Various Length Definitions ***********************/
|
||||||
|
#define SHA256_BLOCK_LENGTH 64
|
||||||
|
#define SHA256_DIGEST_LENGTH 32
|
||||||
|
#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
|
||||||
|
#define SHA384_BLOCK_LENGTH 128
|
||||||
|
#define SHA384_DIGEST_LENGTH 48
|
||||||
|
#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1)
|
||||||
|
#define SHA512_BLOCK_LENGTH 128
|
||||||
|
#define SHA512_DIGEST_LENGTH 64
|
||||||
|
#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
|
||||||
|
|
||||||
|
|
||||||
|
/*** SHA-256/384/512 Context Structures *******************************/
|
||||||
|
/* NOTE: If your architecture does not define either u_intXX_t types or
|
||||||
|
* uintXX_t (from inttypes.h), you may need to define things by hand
|
||||||
|
* for your system:
|
||||||
|
*/
|
||||||
|
#if 0
|
||||||
|
typedef unsigned char u_int8_t; /* 1-byte (8-bits) */
|
||||||
|
typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */
|
||||||
|
typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */
|
||||||
|
#endif
|
||||||
|
/*
|
||||||
|
* Most BSD systems already define u_intXX_t types, as does Linux.
|
||||||
|
* Some systems, however, like Compaq's Tru64 Unix instead can use
|
||||||
|
* uintXX_t types defined by very recent ANSI C standards and included
|
||||||
|
* in the file:
|
||||||
|
*
|
||||||
|
* #include <inttypes.h>
|
||||||
|
*
|
||||||
|
* If you choose to use <inttypes.h> then please define:
|
||||||
|
*
|
||||||
|
* #define SHA2_USE_INTTYPES_H
|
||||||
|
*
|
||||||
|
* Or on the command line during compile:
|
||||||
|
*
|
||||||
|
* cc -DSHA2_USE_INTTYPES_H ...
|
||||||
|
*/
|
||||||
|
#ifdef SHA2_USE_INTTYPES_H
|
||||||
|
|
||||||
|
typedef struct _SHA256_CTX {
|
||||||
|
uint32_t state[8];
|
||||||
|
uint64_t bitcount;
|
||||||
|
uint8_t buffer[SHA256_BLOCK_LENGTH];
|
||||||
|
} SHA256_CTX;
|
||||||
|
typedef struct _SHA512_CTX {
|
||||||
|
uint64_t state[8];
|
||||||
|
uint64_t bitcount[2];
|
||||||
|
uint8_t buffer[SHA512_BLOCK_LENGTH];
|
||||||
|
} SHA512_CTX;
|
||||||
|
|
||||||
|
#else /* SHA2_USE_INTTYPES_H */
|
||||||
|
|
||||||
|
typedef struct _SHA256_CTX {
|
||||||
|
u_int32_t state[8];
|
||||||
|
u_int64_t bitcount;
|
||||||
|
u_int8_t buffer[SHA256_BLOCK_LENGTH];
|
||||||
|
} SHA256_CTX;
|
||||||
|
typedef struct _SHA512_CTX {
|
||||||
|
u_int64_t state[8];
|
||||||
|
u_int64_t bitcount[2];
|
||||||
|
u_int8_t buffer[SHA512_BLOCK_LENGTH];
|
||||||
|
} SHA512_CTX;
|
||||||
|
|
||||||
|
#endif /* SHA2_USE_INTTYPES_H */
|
||||||
|
|
||||||
|
typedef SHA512_CTX SHA384_CTX;
|
||||||
|
|
||||||
|
|
||||||
|
/*** SHA-256/384/512 Function Prototypes ******************************/
|
||||||
|
#ifndef NOPROTO
|
||||||
|
#ifdef SHA2_USE_INTTYPES_H
|
||||||
|
|
||||||
|
void SHA256_Init(SHA256_CTX *);
|
||||||
|
void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
|
||||||
|
void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
|
||||||
|
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||||
|
char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||||
|
|
||||||
|
void SHA384_Init(SHA384_CTX*);
|
||||||
|
void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
|
||||||
|
void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
|
||||||
|
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||||
|
char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||||
|
|
||||||
|
void SHA512_Init(SHA512_CTX*);
|
||||||
|
void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
|
||||||
|
void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
|
||||||
|
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||||
|
char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||||
|
|
||||||
|
#else /* SHA2_USE_INTTYPES_H */
|
||||||
|
|
||||||
|
void SHA256_Init(SHA256_CTX *);
|
||||||
|
void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
|
||||||
|
void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
|
||||||
|
char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||||
|
char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
|
||||||
|
|
||||||
|
void SHA384_Init(SHA384_CTX*);
|
||||||
|
void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
|
||||||
|
void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
|
||||||
|
char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||||
|
char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
|
||||||
|
|
||||||
|
void SHA512_Init(SHA512_CTX*);
|
||||||
|
void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
|
||||||
|
void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
|
||||||
|
char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||||
|
char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
|
||||||
|
|
||||||
|
#endif /* SHA2_USE_INTTYPES_H */
|
||||||
|
|
||||||
|
#else /* NOPROTO */
|
||||||
|
|
||||||
|
void SHA256_Init();
|
||||||
|
void SHA256_Update();
|
||||||
|
void SHA256_Final();
|
||||||
|
char* SHA256_End();
|
||||||
|
char* SHA256_Data();
|
||||||
|
|
||||||
|
void SHA384_Init();
|
||||||
|
void SHA384_Update();
|
||||||
|
void SHA384_Final();
|
||||||
|
char* SHA384_End();
|
||||||
|
char* SHA384_Data();
|
||||||
|
|
||||||
|
void SHA512_Init();
|
||||||
|
void SHA512_Update();
|
||||||
|
void SHA512_Final();
|
||||||
|
char* SHA512_End();
|
||||||
|
char* SHA512_Data();
|
||||||
|
|
||||||
|
#endif /* NOPROTO */
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif /* __cplusplus */
|
||||||
|
|
||||||
|
#endif /* __SHA2_H__ */
|
||||||
|
|
||||||
23
src/signatures.h
Normal file
23
src/signatures.h
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This file is part of Codecrypt.
|
||||||
|
*
|
||||||
|
* Codecrypt is free software: you can redistribute it and/or modify it
|
||||||
|
* under the terms of the GNU Lesser General Public License as published by
|
||||||
|
* the Free Software Foundation, either version 3 of the License, or (at
|
||||||
|
* your option) any later version.
|
||||||
|
*
|
||||||
|
* Codecrypt is distributed in the hope that it will be useful, but WITHOUT
|
||||||
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
||||||
|
* License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU Lesser General Public License
|
||||||
|
* along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _ccr_sigs_h_
|
||||||
|
#define _ccr_sigs_h_
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
Loading…
Reference in a new issue