Test::Result run_one_test(const std::string& hash_algo, const VarMap& vars) override
{
Test::Result result("HOTP " + hash_algo);
std::unique_ptr<Botan::HashFunction> hash_test = Botan::HashFunction::create(hash_algo);
if(!hash_test)
return {result};
const std::vector<uint8_t> key = get_req_bin(vars, "Key");
const size_t otp = get_req_sz(vars, "OTP");
const uint64_t counter = get_req_sz(vars, "Counter");
const size_t digits = get_req_sz(vars, "Digits");
Botan::HOTP hotp(key, hash_algo, digits);
result.test_eq("OTP", hotp.generate_hotp(counter), otp);
std::pair<bool, uint64_t> otp_res = hotp.verify_hotp(otp, counter, 0);
result.test_eq("OTP verify result", otp_res.first, true);
result.confirm("OTP verify next counter", otp_res.second == counter + 1);
// Test invalid OTP
otp_res = hotp.verify_hotp(otp + 1, counter, 0);
result.test_eq("OTP verify result", otp_res.first, false);
result.confirm("OTP verify next counter", otp_res.second == counter);
// Test invalid OTP with long range
otp_res = hotp.verify_hotp(otp + 1, counter, 100);
result.test_eq("OTP verify result", otp_res.first, false);
result.confirm("OTP verify next counter", otp_res.second == counter);
// Test valid OTP with long range
otp_res = hotp.verify_hotp(otp, counter - 90, 100);
result.test_eq("OTP verify result", otp_res.first, true);
result.confirm("OTP verify next counter", otp_res.second == counter + 1);
return result;
}
static gboolean
pluginCore (piArgs *argp)
{
GimpDrawable *drw, *ndrw = NULL;
GimpPixelRgn srcPr, dstPr;
gboolean success = TRUE;
gint nl = 0;
gint y, i;
gint Y, I, Q;
guint width, height, bpp;
gint sel_x1, sel_x2, sel_y1, sel_y2;
gint prog_interval;
guchar *src, *s, *dst, *d;
guchar r, prev_r=0, new_r=0;
guchar g, prev_g=0, new_g=0;
guchar b, prev_b=0, new_b=0;
gdouble fy, fc, t, scale;
gdouble pr, pg, pb;
gdouble py;
drw = gimp_drawable_get (argp->drawable);
width = drw->width;
height = drw->height;
bpp = drw->bpp;
if (argp->new_layerp)
{
gchar name[40];
const gchar *mode_names[] =
{
"ntsc",
"pal",
};
const gchar *action_names[] =
{
"lum redux",
"sat redux",
"flag",
};
g_snprintf (name, sizeof (name), "hot mask (%s, %s)",
mode_names[argp->mode],
action_names[argp->action]);
nl = gimp_layer_new (argp->image, name, width, height,
GIMP_RGBA_IMAGE, (gdouble)100, GIMP_NORMAL_MODE);
ndrw = gimp_drawable_get (nl);
gimp_drawable_fill (nl, GIMP_TRANSPARENT_FILL);
gimp_image_insert_layer (argp->image, nl, -1, 0);
}
gimp_drawable_mask_bounds (drw->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
width = sel_x2 - sel_x1;
height = sel_y2 - sel_y1;
src = g_new (guchar, width * height * bpp);
dst = g_new (guchar, width * height * 4);
gimp_pixel_rgn_init (&srcPr, drw, sel_x1, sel_y1, width, height,
FALSE, FALSE);
if (argp->new_layerp)
{
gimp_pixel_rgn_init (&dstPr, ndrw, sel_x1, sel_y1, width, height,
FALSE, FALSE);
}
else
{
gimp_pixel_rgn_init (&dstPr, drw, sel_x1, sel_y1, width, height,
TRUE, TRUE);
}
gimp_pixel_rgn_get_rect (&srcPr, src, sel_x1, sel_y1, width, height);
s = src;
d = dst;
build_tab (argp->mode);
gimp_progress_init (_("Hot"));
prog_interval = height / 10;
for (y = sel_y1; y < sel_y2; y++)
{
gint x;
if (y % prog_interval == 0)
gimp_progress_update ((double) y / (double) (sel_y2 - sel_y1));
for (x = sel_x1; x < sel_x2; x++)
{
if (hotp (r = *(s + 0), g = *(s + 1), b = *(s + 2)))
{
if (argp->action == ACT_FLAG)
{
for (i = 0; i < 3; i++)
*d++ = 0;
s += 3;
if (bpp == 4)
*d++ = *s++;
else if (argp->new_layerp)
*d++ = 255;
}
else
{
/*
* Optimization: cache the last-computed hot pixel.
*/
if (r == prev_r && g == prev_g && b == prev_b)
{
*d++ = new_r;
*d++ = new_g;
*d++ = new_b;
s += 3;
if (bpp == 4)
*d++ = *s++;
else if (argp->new_layerp)
*d++ = 255;
}
else
{
Y = tab[0][0][r] + tab[0][1][g] + tab[0][2][b];
I = tab[1][0][r] + tab[1][1][g] + tab[1][2][b];
Q = tab[2][0][r] + tab[2][1][g] + tab[2][2][b];
prev_r = r;
prev_g = g;
prev_b = b;
/*
* Get Y and chroma amplitudes in floating point.
*
* If your C library doesn't have hypot(), just use
* hypot(a,b) = sqrt(a*a, b*b);
*
* Then extract linear (un-gamma-corrected)
* floating-point pixel RGB values.
*/
fy = (double)Y / (double)SCALE;
fc = hypot ((double) I / (double) SCALE,
(double) Q / (double) SCALE);
pr = (double) pix_decode (r);
pg = (double) pix_decode (g);
pb = (double) pix_decode (b);
/*
* Reducing overall pixel intensity by scaling R,
* G, and B reduces Y, I, and Q by the same factor.
* This changes luminance but not saturation, since
* saturation is determined by the chroma/luminance
* ratio.
*
* On the other hand, by linearly interpolating
* between the original pixel value and a grey
* pixel with the same luminance (R=G=B=Y), we
* change saturation without affecting luminance.
*/
if (argp->action == ACT_LREDUX)
{
/*
* Calculate a scale factor that will bring the pixel
* within both chroma and composite limits, if we scale
* luminance and chroma simultaneously.
*
* The calculated chrominance reduction applies
* to the gamma-corrected RGB values that are
* the input to the RGB-to-YIQ operation.
* Multiplying the original un-gamma-corrected
* pixel values by the scaling factor raised to
* the "gamma" power is equivalent, and avoids
* calling gc() and inv_gc() three times each. */
scale = chroma_lim / fc;
t = compos_lim / (fy + fc);
if (t < scale)
scale = t;
scale = pow (scale, mode[argp->mode].gamma);
r = (guint8) pix_encode (scale * pr);
g = (guint8) pix_encode (scale * pg);
b = (guint8) pix_encode (scale * pb);
}
else
{ /* ACT_SREDUX hopefully */
/*
* Calculate a scale factor that will bring the
* pixel within both chroma and composite
* limits, if we scale chroma while leaving
* luminance unchanged.
*
* We have to interpolate gamma-corrected RGB
* values, so we must convert from linear to
* gamma-corrected before interpolation and then
* back to linear afterwards.
*/
scale = chroma_lim / fc;
t = (compos_lim - fy) / fc;
if (t < scale)
scale = t;
pr = gc (pr, argp->mode);
pg = gc (pg, argp->mode);
pb = gc (pb, argp->mode);
py = pr * mode[argp->mode].code[0][0] +
pg * mode[argp->mode].code[0][1] +
pb * mode[argp->mode].code[0][2];
r = pix_encode (inv_gc (py + scale * (pr - py),
argp->mode));
g = pix_encode (inv_gc (py + scale * (pg - py),
argp->mode));
b = pix_encode (inv_gc (py + scale * (pb - py),
argp->mode));
}
*d++ = new_r = r;
*d++ = new_g = g;
*d++ = new_b = b;
s += 3;
if (bpp == 4)
*d++ = *s++;
else if (argp->new_layerp)
*d++ = 255;
}
}
}
else
{
if (!argp->new_layerp)
{
for (i = 0; i < bpp; i++)
*d++ = *s++;
}
else
{
s += bpp;
d += 4;
}
}
}
}
gimp_pixel_rgn_set_rect (&dstPr, dst, sel_x1, sel_y1, width, height);
g_free (src);
g_free (dst);
if (argp->new_layerp)
{
gimp_drawable_flush (ndrw);
gimp_drawable_update (nl, sel_x1, sel_y1, width, height);
}
else
{
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, sel_x1, sel_y1, width, height);
}
gimp_displays_flush ();
return success;
}
int32_t totp(const uint8_t* K, const size_t Klen, const time_t T, const int digits)
{
uint64_t C = (T - T0) / TI;
return hotp(K, Klen, C, digits);
}
