diff options
Diffstat (limited to 'Master/Public-Key-Algorithmen/Prakt4/main.cpp')
| -rwxr-xr-x | Master/Public-Key-Algorithmen/Prakt4/main.cpp | 447 |
1 files changed, 447 insertions, 0 deletions
diff --git a/Master/Public-Key-Algorithmen/Prakt4/main.cpp b/Master/Public-Key-Algorithmen/Prakt4/main.cpp new file mode 100755 index 0000000..7215a9d --- /dev/null +++ b/Master/Public-Key-Algorithmen/Prakt4/main.cpp @@ -0,0 +1,447 @@ +#include <stdlib.h>
+//#include <windows.h>
+#include <time.h>
+#include <stdio.h>
+#include <Math.h>
+
+
+typedef unsigned int uint32_t;
+
+
+void initRandomizer();
+uint32_t getRandomUint32(uint32_t length);
+
+void f2m_rand(uint32_t t, uint32_t m, uint32_t *A);
+void f2m_print(uint32_t t, uint32_t *A);
+void f2m_assign(uint32_t t, uint32_t *A, uint32_t *B);
+void f2m_and(uint32_t t, uint32_t *A, uint32_t *B, uint32_t *C);
+void f2m_or(uint32_t t, uint32_t *A, uint32_t *B, uint32_t *C);
+void f2m_xor(uint32_t t, uint32_t *A, uint32_t *B, uint32_t *C);
+void f2m_shiftleft(uint32_t t, uint32_t *A, uint32_t *B);
+void f2m_shiftright(uint32_t t, uint32_t *A, uint32_t *B);
+uint32_t getbit(uint32_t U, uint32_t i);
+uint32_t f2m_bitm(uint32_t t, uint32_t m, uint32_t *A);
+
+uint32_t f2m_biti(uint32_t t,uint32_t i,uint32_t *A);
+void f2m_one(uint32_t t,uint32_t *A);
+void f2m_zero(uint32_t t,uint32_t *A);
+uint32_t f2m_is_equal(uint32_t t,uint32_t *A,uint32_t *B);
+uint32_t f2m_is_one(uint32_t t,uint32_t *A);
+uint32_t f2m_is_zero(uint32_t t,uint32_t *A);
+void f2m_mul(uint32_t t,uint32_t m,uint32_t *A,uint32_t *B,uint32_t *F,uint32_t *C,uint32_t *T1,uint32_t *T2);
+void f2m_inv(uint32_t t,uint32_t m,uint32_t *A,uint32_t *F,uint32_t *B,uint32_t *U,uint32_t *V,uint32_t *T1,uint32_t *T2);
+uint32_t f2m_deg(uint32_t,uint32_t,uint32_t*);
+void build_f(uint32_t,uint32_t,uint32_t*);
+
+int main(int argc, char* argv[])
+{
+ initRandomizer();
+ uint32_t m = 163;
+ //double x = static_cast<double>(m>>5);
+ double x = static_cast<double>( ((double)m) / 32);
+ uint32_t t = ceil(x);
+ uint32_t *A,*B,*C,*U,*V,*T1,*T2,*F,*R1,*R2,*R3,*R4;
+ long s = sizeof(uint32_t);
+ long bytes = s*t;
+ A = (uint32_t*) malloc(bytes);
+ B = (uint32_t*) malloc(bytes);
+ C = (uint32_t*) malloc(bytes);
+ U = (uint32_t*) malloc(bytes);
+ V = (uint32_t*) malloc(bytes);
+ T1 = (uint32_t*) malloc(bytes);
+ T2 = (uint32_t*) malloc(bytes);
+ F = (uint32_t*) malloc(bytes);
+ R1 = (uint32_t*) malloc(bytes);
+ R2 = (uint32_t*) malloc(bytes);
+ R3 = (uint32_t*) malloc(bytes);
+ R4 = (uint32_t*) malloc(bytes);
+
+ f2m_zero(t,A);
+ f2m_print(t,A);
+ if(f2m_is_zero(t,A))
+ printf("A is zero \n");
+
+ f2m_one(t,A);
+ f2m_print(t,A);
+ if(f2m_is_one(t,A))
+ printf("A is one \n");
+
+ uint32_t bit;
+ bit = f2m_biti(t,0,A);
+ if(bit == 1)
+ printf("Bit 1 of A is 1\n");
+ else
+ printf("Bit 1 of A is %u\n",bit);
+
+ if (f2m_is_equal(t,A,A) )
+ printf("A equal A\n");
+ else
+ printf("A not equal A ?!\n");
+ build_f(t,m,F);
+ uint32_t degF = f2m_deg(t,m,F);
+ printf("Deg(F) = %u\n",degF);
+ bool hasError = false;
+ for(uint32_t n = 0;n<10000;n++) {
+ f2m_rand(t,m,A);
+ /*f2m_rand(t,m,B);
+ f2m_rand(t,m,C);
+
+ f2m_mul(t,m,A,B,F,R1,T1,T2);
+ f2m_mul(t,m,R1,C,F,R2,T1,T2);
+
+ f2m_mul(t,m,B,C,F,R3,T1,T2);
+ f2m_mul(t,m,A,R3,F,R4,T1,T2);
+
+ if(f2m_is_equal(t,R2,R4))
+ printf("Mul works correctly\n");
+ else
+ printf("Mul is not working correctly\n");
+ */
+ f2m_inv(t,m,A,F,R1,U,V,T1,T2);
+ f2m_mul(t,m,A,R1,F,R2,T1,T2);
+
+ if(n%100 == 0){
+ printf("%u\n",n );
+ }
+
+ if(!f2m_is_one(t,R2))
+ {
+ hasError = true;
+ break;
+ }
+ }
+ if(!hasError)
+ printf("Inv works correctly\n");
+ else
+ printf("Inv is not working correctly\n");
+
+ //f2m_assign(t,A,B);
+ //printf("\n\n\n");
+ //f2m_print(t,B);
+
+ /*
+
+ f2m_and(t,A,A,C);
+
+ printf("A&A: \n");
+ f2m_print(t,C);
+
+ printf("A: \n");
+ f2m_print(t,A);
+
+ printf("B: \n");
+ f2m_print(t,B);
+
+ f2m_and(t,A,B,C);
+
+ printf("A&B: \n");
+ f2m_print(t,C);
+
+ printf("A << 1: \n");
+ f2m_shiftleft(t,A,B);
+ f2m_print(t,B);
+ uint32_t test[] = {0x1,0x0};
+ f2m_print(2,&test[0]);
+ for(int i=0;i<63;i++) {
+ f2m_shiftleft(2,&test[0],&test[0]);
+ f2m_print(2,&test[0]);
+ }
+ for(int i=0;i<63;i++) {
+ f2m_shiftright(2,&test[0],&test[0]);
+ f2m_print(2,&test[0]);
+ }
+ printf("0 OR 1: \n");
+ test[0] = 0x0;
+ test[1] = 0x0;
+ uint32_t test2[] = {0x1,0x0};
+ uint32_t test3[2];
+ f2m_or(2,&test[0],&test2[0],&test3[0]);
+ f2m_print(2,&test3[0]);
+
+ printf("1 XOR 1: \n");
+ test[0] = 0x1;
+ test[1] = 0x0;
+ test2[0] = 0x1;
+ test2[1] = 0x0;
+ f2m_xor(2,&test[0],&test2[0],&test3[0]);
+ f2m_print(2,&test3[0]);
+ */
+ getchar();
+ free(A);
+ free(B);
+ free(C);
+ free(F);
+ free(U);
+ free(V);
+ free(T1);
+ free(T2);
+ free(R1);
+ free(R2);
+ free(R3);
+ free(R4);
+ return 0;
+}
+
+void initRandomizer()
+{
+ srand(time(NULL));
+}
+uint32_t getRandomUint32()
+{
+ uint32_t resLow = rand();
+ uint32_t resHigh = rand();
+ uint32_t res;
+ res = resHigh << 15;
+ res = res | (resLow);
+ return res;
+}
+
+void f2m_rand(uint32_t t, uint32_t m, uint32_t *A)
+{
+ for(int i=t-1;i>=0;i--)
+ {
+ A[i]= getRandomUint32();
+ }
+
+ uint32_t mask = 0x0;
+ uint32_t unEvenBytes = m%32;
+ if (unEvenBytes != 0) {
+ for(uint32_t i=0;i<(unEvenBytes)-1;i++) {
+ mask |= (1<<i);
+ }
+ A[t-1] &= mask;
+ }
+}
+
+void f2m_print(uint32_t t, uint32_t *A)
+{
+ for(int i=t-1;i>=0;i--)
+ {
+ printf("%08X ",A[i]);
+ if(!(i%4))
+ printf("\n");
+ }
+}
+
+void f2m_assign(uint32_t t, uint32_t *A, uint32_t *B)
+{
+ for(int i=t-1;i>=0;i--)
+ {
+ B[i]=A[i];
+ }
+}
+void f2m_and(uint32_t t, uint32_t *A, uint32_t *B, uint32_t *C)
+{
+ for(int i=t-1;i>=0;i--)
+ {
+ C[i] = (B[i] & A[i]);
+ }
+}
+
+void f2m_or(uint32_t t, uint32_t *A, uint32_t *B, uint32_t *C)
+{
+ for(int i=t-1;i>=0;i--)
+ {
+ C[i] = (B[i] | A[i]);
+ }
+}
+
+void f2m_xor(uint32_t t, uint32_t *A, uint32_t *B, uint32_t *C)
+{
+ for(int i=t-1;i>=0;i--)
+ {
+ C[i] = (B[i] ^ A[i]);
+ }
+}
+
+void f2m_shiftleft(uint32_t t, uint32_t *A, uint32_t *B)
+{
+ for(int i=t-1;i>0;i--)
+ {
+ B[i] = ((A [i] << 1)| getbit(A[i-1],31));
+ }
+ B[0] = A [0] << 1;
+}
+void f2m_shiftright(uint32_t t, uint32_t *A, uint32_t *B)
+{
+ for(uint32_t n=0;n<(t-1);n++)
+ {
+ B[n] = ((A[n]>> 1)| (getbit(A[n+1],0)<<31));
+ }
+ B[t-1] = A[t-1]>> 1;
+}
+
+uint32_t getbit(uint32_t U, uint32_t i)
+{
+ if(i==0)
+ return U & 0x1;
+ else
+ return ((U>> i)& 0x1);
+}
+
+uint32_t f2m_bitm(uint32_t t, uint32_t m, uint32_t *A)
+{
+ /*
+ int modul = m%32;
+ if(modul!=0)
+ return getbit(A[t-1],(m%32)-1);
+ else
+ return getbit(A[t-1],31);
+ */
+ return f2m_biti(t,m,A);
+}
+
+uint32_t f2m_biti(uint32_t t,uint32_t i,uint32_t *A)
+{
+ return getbit(A[i / 32],i % 32);
+}
+void f2m_one(uint32_t t,uint32_t *A)
+{
+ for(uint32_t i=1; i<t; i++)
+ {
+ A[i] = 0;
+ }
+ A[0]=1;
+}
+void f2m_zero(uint32_t t,uint32_t *A)
+{
+ for(uint32_t i=0; i<t; i++)
+ {
+ A[i] = 0;
+ }
+}
+uint32_t f2m_is_equal(uint32_t t,uint32_t *A,uint32_t *B)
+{
+ for(uint32_t i=0; i<t; i++)
+ {
+ if(A[i] != B[i])
+ return 0;
+ }
+ return 1;
+}
+uint32_t f2m_is_one(uint32_t t,uint32_t *A)
+{
+ for(uint32_t i=1; i<t; i++)
+ {
+ if(A[i] != 0)
+ return 0;
+ }
+ if(A[0] != 1)
+ return 0;
+ return 1;
+}
+uint32_t f2m_is_zero(uint32_t t,uint32_t *A)
+{
+ for(uint32_t i=0; i<t; i++)
+ {
+ if(A[i] != 0)
+ return 0;
+ }
+ return 1;
+}
+void f2m_mul(uint32_t t,uint32_t m,uint32_t *A,uint32_t *B,uint32_t *F,uint32_t *C,uint32_t *T1,uint32_t *T2)
+{
+ f2m_assign(t,B,T1);
+ f2m_zero(t,T2);
+ for(uint32_t i=0;i<m-1;i++){
+ if( f2m_biti(t,m,T1) == 1 )
+ {
+ f2m_xor(t,T1, F ,T1);
+ }
+ if ( f2m_biti(t,i,A) == 1)
+ {
+ f2m_xor(t,T2,T1,T2);
+ }
+ f2m_shiftleft(t,T1,T1);
+ }
+ f2m_assign(t,T2,C);
+}
+
+uint32_t f2m_deg(uint32_t t,uint32_t m, uint32_t* A)
+{
+ /*
+ for(uint32_t i = t-1; i >= 0; i--)
+ {
+ if(A[i] != 0)
+ {
+ for(uint32_t x=31;x>=0;x--)
+ {
+ if( getbit(A[i],x) == 0x1 )
+ {
+ return (i*32)+x+1;
+ }
+ }
+ }
+ }
+ */
+ for(uint32_t pos=m;pos>=0;pos--)
+ {
+ if(f2m_biti(t,pos,A) == 0x1)
+ {
+ return pos;
+ }
+ }
+ return 0;
+}
+
+void f2m_inv(uint32_t t,uint32_t m,uint32_t *A,uint32_t *F,uint32_t *B,uint32_t *U,uint32_t *V,uint32_t *T1,uint32_t *T2)
+{
+ f2m_assign(t,A,U);
+ f2m_assign(t,F,V);
+ f2m_one(t,T1);
+ f2m_zero(t,T2);
+ while( !f2m_is_one(t,U) && !f2m_is_one(t,V) )
+ {
+ while(f2m_biti(t,0,U) == 0 && !f2m_is_zero(t,U) )
+ {
+ f2m_shiftright(t,U,U);
+ if(f2m_biti(t,0,T1) == 0 && !f2m_is_zero(t,T1) )
+ {
+ f2m_shiftright(t,T1,T1);
+ }
+ else
+ {
+ f2m_xor(t,T1,F,T1);
+ f2m_shiftright(t,T1,T1);
+ }
+ }
+ while(f2m_biti(t,0,V) == 0 && !f2m_is_zero(t,V) )
+ {
+ f2m_shiftright(t,V,V);
+ if(f2m_biti(t,0,T2) == 0 && !f2m_is_zero(t,T2) )
+ {
+ f2m_shiftright(t,T2,T2);
+ }
+ else
+ {
+ f2m_xor(t,T2,F,T2);
+ f2m_shiftright(t,T2,T2);
+ }
+ }
+ if(f2m_deg(t,m,U) > f2m_deg(t,m,V))
+ {
+ f2m_xor(t,U,V,U);
+ f2m_xor(t,T1,T2,T1);
+ }
+ else
+ {
+ f2m_xor(t,U,V,V);
+ f2m_xor(t,T1,T2,T2);
+ }
+ }
+ if(f2m_is_one(t,U))
+ {
+ f2m_assign(t,T1,B);
+ }
+ else
+ {
+ f2m_assign(t,T2,B);
+ }
+}
+void build_f(uint32_t t,uint32_t m,uint32_t* F)
+{
+ f2m_zero(t,F);
+ F[5] = 1<<3;
+ F[0] = 0xC9;
+ f2m_print(t,F);
+}
\ No newline at end of file |