Re: xorpng

On 1/5/2025 3:06 PM, Stefan Claas wrote:

Chris M. Thomasson wrote:

On 1/5/2025 2:48 PM, Chris M. Thomasson wrote:

On 1/5/2025 1:10 PM, Stefan Claas wrote:

Rich wrote:

Stefan Claas <pollux@tilde.club> wrote:

Rich wrote:

Stefan Claas <pollux@tilde.club> wrote:

Stefan Claas wrote:

Rich wrote:

Stefan Claas <pollux@tilde.club> wrote:

Rich wrote:
>

If instead you mean some kind of "special, PNG aware,
encryptor that only encrypted the bitmap data of a PNG",
but left the file as otherwise a proper PNG image
structure, then that is slightly tricky (and an algorithm
that is only useful for PNG's alone).

>
Yes, this is what I mean.

>
Which brings up the question of: why?
>
Why go to the trouble to create an encryptor that is
specalized for just encrypting the internal bitmap data within
a PNG, leaving the rest as a PNG file, when a generic "byte
stream" encryptor will encrypt the entire PNG with no extra
effort?

>
To make more content as allowed postable on social media, like
X.

>
I.e, first you put data with file2png in a .png and then encrypt
it to finally post it.  I can do this now with my xorpic program,
but I thought a solution with AES-GCM or XChaCha20+ploy1305 is
better.

>
The "path" I outlined in my previous post, where you utilize the
netpbm image format as your 'intermediary' would allow you to use
any generic encryption routine you like, while also allowing you to
convert the encrypted binary data to/from an image format of your
choice (well, your choice within the set of other formats for which
NetPBM has to/from converters available).
>
This frees you from having to understand the internal structure of
the various image formats.  You just work with the netpbm format (a
raw binary bit/pixel block) for the encrypt/decrypt/padding
operations, and delegate all the "image format" complexity to the
netpbm library.

>
Thank you!  My ppmenc tool works nicely, here are the test images:
>
https://jmp.sh/HZM9ML9f
>
The big problem I face when converting the encryypted image to .png
and back a diff shows a difference and the decryption fails.
>
Maybe someone can figure out what to do, so that a converted .ppm can
be posted online , for viewers/readers and then can be converted back
to the original .ppm, which shows no difference.

>
We can't read your mind over Usenet so can you show how you converted
the encrypted image to a png and back.
>

>
I used Gimp with compression set to 0 and the netbmp tools.
>

>
You should write your own program for it. The Gimp altered some bytes,
right?

>
Fwiw, the Cairo lib is fairly nice, well, to me at least... I use it a
lot for my 2d work. it allows you to gain access to the raw underlying
buffer. So, I can create PNG's with payloads that are intact.

 Ok, here is the deal ... I have file2png (Go and Python3) which converts
any (encrypted) payload to valid noise .png images and back. I have xorpng
in Go which can create .png keys of random noise (crypto/rand) and xor
then .png images with them, to create encrypted noise images. I have ppmenc
in Go which encrypts ppm (P6) images to noise images. What I can not work
out is to convert a ppm to .png and back to the *original* .ppm (P6) file,
because .png with programs used or the Go library alter the conversion,
back to .ppm (P6). I tried many things and always failed.
 *Please* try to write a .ppm (P6) to .png converter (and back) in C(++)
and see if you can get the *original* data back. The sci.crypt community
and me of course would appreciate your help very much!
 

I can, but I am busy with other things. I wrote a PPM reader a long time ago. decades. Just parse the PPM (P6) format. Here is a program I wrote in C that stores PPM's as a series of slices for a 3d volumetric object. The ct_canvas_save_ppm creates a PPM. The fun part is that the image stack is a volumetric object that can even be made into a hologram.
_______________________
/*
     A Simple 2d Plane For Owen, with proper aspect ratios!
     Color adder, single channel
     By: Chris M. Thomasson
*_____________________________________________________________*/
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <complex.h>
#include <tgmath.h>
#include <stdbool.h>
#define CT_WIDTH 1920
#define CT_HEIGHT 1080
#define CT_N 10000000
struct ct_rgb
{
     unsigned char r;
     unsigned char g;
     unsigned char b;
};
struct ct_canvas
{
     unsigned long width;
     unsigned long height;
     //unsigned char* buf;
     struct ct_rgb* buf;
};
bool
ct_canvas_create(
     struct ct_canvas* const self,
     unsigned long width,
     unsigned long height
){
     size_t size = width * height * sizeof(*self->buf);
     self->buf = calloc(1, size);
     if (self->buf)
     {
         self->width = width;
         self->height = height;
         return true;
     }
     return false;
}
void
ct_canvas_destroy(
     struct ct_canvas const* const self
){
     free(self->buf);
}
bool
ct_canvas_save_ppm(
     struct ct_canvas const* const self,
     char const* fname
){
     FILE* fout = fopen(fname, "wb");
     if (fout)
     {
         // P6 by Bart over on:
         // https://groups.google.com/forum/#!original/comp.lang.c/4196m3Raggs/2moZ67o5EwAJ
         char const ppm_head[] =
             "P6\n"
             "# Chris M. Thomasson Simple 2d Plane ver:0.0.0.0 (pre-alpha)";
         fprintf(fout, "%s\n%lu %lu\n%u\n",
                 ppm_head,
                 self->width, self->height,
                 255U);
         size_t size = self->width * self->height;
         for (size_t i = 0; i < size; ++i)
         {
             //unsigned int c = self->buf[i];
             struct ct_rgb* c = self->buf + i;
             fprintf(fout, "%c%c%c", c->r, c->g, c->b);
             //fprintf(fout, "%c%c%c", c, 0U, 0U);
         }
         if (! fclose(fout))
         {
             return true;
         }
     }
     return false;
}
struct ct_axes
{
     double xmin;
     double xmax;
     double ymin;
     double ymax;
};
struct ct_axes
ct_axes_from_point(
     double complex z,
     double radius
){
     struct ct_axes axes = {
         creal(z) - radius, creal(z) + radius,
         cimag(z) - radius, cimag(z) + radius
     };
     return axes;
}
struct ct_plane
{
     struct ct_axes axes;
     double xstep;
     double ystep;
};
void
ct_plane_init(
     struct ct_plane* const self,
     struct ct_axes const* axes,
     unsigned long width,
     unsigned long height
){
     self->axes = *axes;
     double awidth = self->axes.xmax - self->axes.xmin;
     double aheight = self->axes.ymax - self->axes.ymin;
     assert(width > 0 && height > 0 && awidth > 0.0);
     double daspect = fabs((double)height / width);
     double waspect = fabs(aheight / awidth);
     if (daspect > waspect)
     {
         double excess = aheight * (daspect / waspect - 1.0);
         self->axes.ymax += excess / 2.0;
         self->axes.ymin -= excess / 2.0;
     }
     else if (daspect < waspect)
     {
         double excess = awidth * (waspect / daspect - 1.0);
         self->axes.xmax += excess / 2.0;
         self->axes.xmin -= excess / 2.0;
     }
     self->xstep = (self->axes.xmax - self->axes.xmin) / width;
     self->ystep = (self->axes.ymax - self->axes.ymin) / height;
}
struct ct_plot
{
     struct ct_plane plane;
     struct ct_canvas* canvas;
};
void
ct_plot_init(
     struct ct_plot* const self,
     struct ct_axes const* axes,
     struct ct_canvas* canvas
){
     ct_plane_init(&self->plane, axes, canvas->width - 1, canvas->height - 1);
     self->canvas = canvas;
}
bool
ct_plot_add(
     struct ct_plot* const self,
     double complex z,
     struct ct_rgb const* color
){
     long x = (creal(z) - self->plane.axes.xmin) / self->plane.xstep;
     long y = (self->plane.axes.ymax - cimag(z)) / self->plane.ystep;
     if (x > -1 && x < (long)self->canvas->width &&
         y > -1 && y < (long)self->canvas->height)
     {
         // Now, we can convert to index.
         size_t i = x + y * self->canvas->width;
         assert(i < self->canvas->height * self->canvas->width);
         struct ct_rgb exist = self->canvas->buf[i];
         exist.r += 1;
         self->canvas->buf[i] = exist;
         return true;
     }
     return true;
}
bool
ct_plot_pixel(
     struct ct_plot* const self,
     long x,
     long y,
     struct ct_rgb const* color
){
     if (x > -1 && x < (long)self->canvas->width &&
         y > -1 && y < (long)self->canvas->height)
     {
         // Now, we can convert to index.
         size_t i = x + y * self->canvas->width;
         assert(i < self->canvas->height * self->canvas->width);
         self->canvas->buf[i] = *color;
         return true;
     }
     return false;
}
double complex
ct_project_to_xy(
     struct ct_plot* const self,
     long x,
     long y
){
     double complex p =
         (self->plane.axes.xmin + x * self->plane.xstep) +
         (self->plane.axes.ymax - y * self->plane.ystep) * I;
     return p;
}
bool
ct_plot_point(
     struct ct_plot* const self,
     double complex z,
     struct ct_rgb const* color
){
     long x = (creal(z) - self->plane.axes.xmin) / self->plane.xstep;
     long y = (self->plane.axes.ymax - cimag(z)) / self->plane.ystep;
     if (x > -1 && x < (long)self->canvas->width &&
         y > -1 && y < (long)self->canvas->height)
     {
         // Now, we can convert to index.
         size_t i = x + y * self->canvas->width;
         assert(i < self->canvas->height * self->canvas->width);
         self->canvas->buf[i] = *color;
         return true;
     }
     return false;
}
// slow, so what for now... ;^)
void ct_circle(
     struct ct_plot* const plot,
     double complex c,
     double radius,
     unsigned int n
){
     double abase = 6.2831853071 / n;
     for (unsigned int i = 0; i < n; ++i)
     {
         double angle = abase * i;
         double complex z =
             (creal(c) + cos(angle) * radius) +
             (cimag(c) + sin(angle) * radius) * I;
         struct ct_rgb rgb = { 255, 255, 255 };
         ct_plot_point(plot, z, &rgb);
     }
}
// Simple 3-ary vector impl, just what I need.
struct ct_vec3
{
     double x;
     double y;
     double z;
};
double ct_vev3_length(
     struct ct_vec3 const p
){
     double sum = p.x * p.x + p.y * p.y + p.z * p.z;
     return sqrt(sum);
}
struct ct_vec3
ct_vec3_add(
     struct ct_vec3 const p,
     struct ct_vec3 const addend
){
     struct ct_vec3 sum = {
         p.x + addend.x,
         p.y + addend.y,
         p.z + addend.z
     };
     return sum;
}
// The Mandelbulb, slice hardcoded
// Animation comes next Owen.
void
ct_iterate_mbulb_pixel(
     struct ct_plot* const plot,
     struct ct_vec3 const z0,
     struct ct_vec3 const c0,
     long x,
     long y,
     unsigned int n
){
     struct ct_vec3 zs = z0;
     struct ct_vec3 cs = c0;
     double power = 3.0;
     for (unsigned long i = 0; i < n; ++i)
     {
         double r = ct_vev3_length(zs);
         double rpower = pow(r, power);
         double angle0 = atan2(zs.z, sqrt(zs.x * zs.x + zs.y * zs.y));
         double angle1 = atan2(zs.y, zs.x);
         struct ct_vec3 znew;
         znew.x = rpower * cos(power * angle1) * cos(power * angle0);
         znew.y = rpower * sin(power * angle1) * cos(power * angle0);
         znew.z = rpower * sin(power * angle0);
         zs = ct_vec3_add(znew, cs);
         if (r > 2.0)
         {
             return;
         }
     }
     struct ct_rgb rgb = { 0, 255, 0 };
     ct_plot_pixel(plot, x, y, &rgb);
}
// Gain the field...
void
ct_iterate_mbulb_plane(
     struct ct_plot* const plot,
     unsigned int n
){
     for (long y = 0; y < plot->canvas->height; ++y)
     {
         for (long x = 0; x < plot->canvas->width; ++x)
         {
             double complex cz = ct_project_to_xy(plot, x, y);
             // Well, our per slice coords...
             struct ct_vec3 z;
             z.x = creal(cz);
             z.y = cimag(cz);
             z.z = 0.1;
             // Iterate the slice
             ct_iterate_mbulb_pixel(plot, z, z, x, y, n);
         }
     }
}
void ct_test_plane(
     struct ct_plot* const plot
){
     ct_iterate_mbulb_plane(plot, 64);
     ct_circle(plot, 0+0*I, 1.0, 2048);
}
int main(void)
{
     struct ct_canvas canvas;
     if (ct_canvas_create(&canvas, CT_WIDTH, CT_HEIGHT))
     {
         double complex plane_origin = 0+0*I;
         double plane_radius = 2.0;
         struct ct_axes axes = ct_axes_from_point(plane_origin, plane_radius);
         struct ct_plot plot;
         ct_plot_init(&plot, &axes, &canvas);
         ct_test_plane(&plot);
         // Our unit circle
         ct_circle(&plot, 0+0*I, 1.0, 2048);
         ct_circle(&plot, 2+0*I, 2.0, 2048);
         ct_circle(&plot, -2+0*I, 2.0, 2048);
         ct_circle(&plot, 0+2*I, 2.0, 2048);
         ct_circle(&plot, 0-2*I, 2.0, 2048);
         ct_canvas_save_ppm(&canvas, "ct_plane.ppm");
         ct_canvas_destroy(&canvas);
         return EXIT_SUCCESS;
     }
     return EXIT_FAILURE;
}
_______________________