[[Delphius]]

Hoy me encontraste un poco inspirado y mi mente medio un ejemplo sencillo de lo que podría ser un algoritmo generador de clave.

No tiene mucha seguridad, ni nada por el estilo... Creería que funcionaría siempre y cuando las imagenes sean muy diferentes. Habría que probar.

La idea que tuve es recorrer la imagen y ponderar los valores RGB según su posición.

El algoritmo que concebí es como sigue:

Código Delphi [-]
function TForm1.GenerarClave(Image: TPicture): integer;
var i,j,k: integer; // coordenadas para movernos por la imagen
                    // k para movernos sobre el canal RGB
    sum, sum_rgb: integer; // suma
    RGB: ^TRGB;
    Bmp: TBitmap;
begin
  if not (Image.Graphic is TBitmap)
     then begin
            Bmp:= TBitmap.Create;
            try
              Bmp.Width:= Image.Width;
              Bmp.Height:= Image.Height;
              Bmp.Canvas.Draw(0,0,Image.Graphic);
              Image.Assign(Bmp);
            finally
              Bmp.Free;
            end;
          end;
  Image.Bitmap.PixelFormat := pf24bit;
  sum := 0;
  for j := 0 to Image.Bitmap.Height - 1 do
    begin
      RGB := Image.Bitmap.ScanLine[j];
      sum_rgb := 0;
      for i := 0 to Image.Bitmap.Width - 1 do
        begin
          // calcular suma RGB
          for k := 1 to 3 do
            sum_rgb := sum_rgb + RGB^[k];
          // vamos guardando las sumas ponderadas en funcion del eje x
          sum_rgb := sum_rgb + (sum_rgb * (i + 1));
          inc(RGB);
        end;
      // volvemos a ponderar la suma, ahora en funcion del eje y
      sum := sum + ((sum + sum_rgb) * (j + 1));
    end;
   result := sum;
end;

siendo TRGB la siguiente estructura:

Código Delphi [-]
TRGB = array[1..3] of byte;

Y un ejemplo de su uso:

Código Delphi [-]
ShowMessage(IntToSTr(GenerarClave(Image1.Picture)));

Como notarás, es un algoritmo demasiado simple... y la clave que genere dependerá mucho del tamaño de la imagen. Pues, cuanto más grande sea, más alto será el valor conseguido.
Si tu deseas obtener un algoritmo que genere claves de un determinado tamaño podría refinarse...

Es tan sólo otra alternativa a tener en cuenta si es que los algoritmos y las fuentes que te pasé te resultan un tanto complicadas.

Puede que otros foristas den un aporte alternativo y/o que esta función sea de base para conseguir algo un poco más elaborado y menos complicado que un RCR, MD5, Hash, etc.

Saludos,