Szyfr VMPC - nie jest różnowartościowy

Witam,

moim zadaniem jest zrobienie prostej aplikacji, która udowadnia że szyfr VMPC nie jest funkcją różną wartościową.

Problem w tym, że nie wiem jak się za to zabrać, tzn. mam obliczyć wartości dla permutacji n-elementowych (wystarczy dla zbiorów do 10) i sprawdzić ile z nich jest takich samych.

Dobrze to rozumiem?

Tutaj jest implementacja całej funkcji, może ktoś mi powiedzieć jak skonstruować taki program?

http://www.szyfrowanie.com/implem/VMPC-CipherMAC-C-POL.txt

Jeżeli zły dział - proszę o przeniesienie do odpowiedniego, pozdrawiam.

Podbijam, prosze o pomoc..

Hmm?
Nikt nie pomoże?

1. Zły dział
2. Szczątkowy opis problemu, wymgający od potencjalnego odpowiadającego dużo czytania zanim będzie wiadomo o co ci w ogóle chodzi
3. Zero informacji o tym co zrobiłeś / próbowałeś zrobić.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace vmpcv2
{
    internal static class Coding
    {



        public static Tuple<byte[], byte> getKey(byte[] Vec, byte[] VecInit)
        {
            int v = Vec.Length;
            int vi = VecInit.Length;
            byte s = 0;
            int n = 0;
            byte[] P = new byte[255];
            for (byte i = 0; i < P.Length; i++)
            {
                P[i] = i;
            }
            for (int m = 0; m < 768; m++)
            {
                n = m % 255;

                s = P[(s + P[n] + Vec[m % v]) % 255];
                var temp = P[n];
                P[n] = P[s];
                P[s] = temp;
            }
            for (int m = 0; m < 768; m++)
            {
                n = m % 255;
                s = P[(s + P[n] + VecInit[m % vi]) % 255];
                var temp = P[n];
                P[n] = P[s];
                P[s] = temp;

            }
            return Tuple.Create(P, s);
        }



        public static IEnumerable<byte> Encode(byte[] Key, byte[] Msg)
        {

           byte[] initv =  {
          0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
       };

            byte n = 0;
            int L = Key.Length;
            Tuple<byte[], byte> kse = getKey(Key, initv);
            byte s = kse.Item2;
            byte[] P = kse.Item1;
            for (int i = 0; i < L; i++)
            {
                s = P[(s + P[n]) % 255];
                yield return P[(P[P[s]] + 1) % 255];
                var temp = P[n];
                P[n] = P[s];
                P[s] = temp;
                n++;
            }


        }



    }
}

Mam coś takiego, ale nie działa to do końca poprawnie, proszę o pomoc.

Jak mam udowodnić, że VMPC nie jest zawsze funkcją różnowartościową?

tutaj pomocnicze materiały: http://www.pieknafunkcja.pl/publi/VMPC_Enigma_2005.pdf

Czego drogi autorze oczekujesz? Wątpię by ktoś na tym forum potrafił wytłumaczyć Ci czym jest funkcja różnowartościowa lepiej, niż jest to opisane w już gotowych źródłach dostępnych w internecie. Nie przedstawiłeś też żadnego, dobrze opisanego problemu programistycznego z którym można było Ci pomóc.

Offtop, fajna ciekawostka ten VMPC, życzę wszystkiego dobrego autorowi, ale w niektórych miejscach trochę fantazjuje Algorytm szyfru strumieniowego VMPC można zapisać przy pomocy trzech linii kodu, podczas gdy zapis algorytmu AES zajmuje kilkaset linii kodu źródło http://www.szyfrowanie.com/.

Wiem, czym jest funkcja różnowartościowa, oczekuje natomiast podpowiedzi na temat tego jak przetestować algorytm VMPC do ukazania wyniku, że algorytm ten nie zawsze taką funkcją jest. Chciałbym także, aby ktoś pomógł mi sprawdzić kod, czy szyfrowanie dziala jak należy.

Pozdrawiam.

Podopowiedź masz na wikipedii, Dr Kamil Kulesza z cambrige stwierdził to co potrzebujesz udowodnić. Poszukałbym jego prac i zapisałem w kodzie jego dowody. Żeby sprawdzić kod pod kątem poprawnego szyfrowania, ktoś trzeci musi znać sam algorytm. Mi osobiście nie chce się zagłębiać w coś co jest w tej chwili tylko akademicką ciekawostką i nie przyda mi się do niczego.

Przeglądałem już prace Kuleszy, z tym, że trudno mi to przełożyć na kod, gdyż opisana jest ona bardzo matematycznie.

W załączniku dodaje testowa wersje mojego programu.

Dlaczego funkcja zawsze jest różnowartosciowa? W pracy doktora Kuleszy stosunek licznosci roznych elementow do liczby permutacji ma wspolczynnik ~0,6

Czy zalezy to od permutacji klucza? Przyjalem ze powinna byc roznowartosciowa dla róznych permutacji klucza.