Dokumentacja pliku MyLib.c

#include "MyLib.h"

Idź do kodu źródłowego tego pliku.

Funkcje

void WyswietlMacierz (int n, int m, double a[][matrix_M])
void ZapisMacierzy (char *NazwaPliku, int n, int m, double a[][matrix_M])
void OdczytMacierzy (const char *NazwaPliku, int *n, int *m, double a[][matrix_M])
int parserCSV (char *buf, char *ws[], int n, const char *delim)
void readCSV (char *nazwaCSV, int *N, struct TLst Lst[])
int NWD (int p, int q)
int NWDr (int p, int q, int *x, int *y)
int pmod (int b, int e, int m)
int testPodziel (int n)
int genKluczeRSA (int *e, int *d, int p, int q)
int sizeF (const char *naF)
void kryptFile (const char *naFout, const char *naFin, int e, int n)
void deKryptFile (const char *naFout, const char *naFin, int d, int n)
int sprRSA (const char *naF1, const char *naF2)

Zmienne

const int matrix_N = 25
const int matrix_M = 25
const char separator [] = ";\r\t\n"
const char sepStr [] = "\""
const int rsa_p = 61
const int rsa_q = 53
const char rsa_naFin [] = "_MyLib.c"
const char rsa_naFcrp [] = "_MyLib.crp"
const char rsa_naFres [] = "_MyLib.res"

Dokumentacja funkcji

void deKryptFile ( const char *  naFout,
const char *  naFin,
int  d,
int  n 
)

deszyfracja pliku zaszyfrowanego metoda RSA

$d, n$ klucz prywatny

Definicja w linii 325 pliku MyLib.c.

Odwołuje się do pmod() i sizeF().

00326 {
00327    FILE *Fout,*Fin;
00328    int i,N,M1,P;
00329    char str[10];
00330 
00331 #if RSA_HEX
00332    N = sizeF(naFin)/8;
00333 #else
00334    N = sizeF(naFin)/sizeof(int);
00335 #endif
00336    Fin = fopen(naFin, "r");
00337    if( Fin==NULL )
00338    {
00339       perror(naFin);
00340       exit(-1);
00341    }
00342    Fout = fopen(naFout, "w");
00343    for(i=0; i<N; i=i+1)
00344    {
00345 #if RSA_HEX
00346       fread(str,8,1,Fin);
00347       str[8] = '\0';
00348       P  = strtol(str,NULL,16);
00349 #else
00350       fread(&P,sizeof(int),1,Fin);
00351 #endif
00352       M1 = pmod(P,d,n);
00353       sprintf(str,"%c", (char)M1);
00354       fwrite(str,1,1,Fout);
00355    }
00356    fclose(Fout);
00357    fclose(Fin);
00358 }

int genKluczeRSA ( int *  e,
int *  d,
int  p,
int  q 
)

generowanie klucza publicznego i prywatnego na rzecz metody szyfrowania RSA

Nota:
liczba $e$ jest wybrana w ten sposob, aby byla wzglednie pierwsza z $\varphi(n) $ tu $\varphi(n)=(p-1)(q-1)$

obliczam $d$ spelniajace $ed = 1 \mathop{\mathrm{mod}} \varphi(n)$

Definicja w linii 230 pliku MyLib.c.

Odwołuje się do NWD(), NWDr() i testPodziel().

00231 {
00232     int n,fi_n,y;
00233 
00234     if(testPodziel(p) || testPodziel(q))
00235     {
00236        puts("Upss ...");
00237        exit(-1);
00238     }
00239     n = p*q;
00240     fi_n = (p-1)*(q-1);
00246     *e = 17;
00247     if( NWD(*e,fi_n)!=1 )
00248     {
00249        puts("Upss ...");
00250        exit(-1);
00251     }
00256     NWDr(*e,fi_n,d,&y);
00257     while( *d<0 )
00258     {
00259        *d = (*d+fi_n) % fi_n;
00260     }
00261     return n;
00262 }

void kryptFile ( const char *  naFout,
const char *  naFin,
int  e,
int  n 
)

szyfrowanie metoda RSA pliku

$e, n$ klucz publiczny

Definicja w linii 286 pliku MyLib.c.

Odwołuje się do pmod() i sizeF().

00287 {
00288    FILE *Fout,*Fin;
00289    int i,N,M0,P;
00290 #if RSA_HEX
00291    char str[10],c;
00292 #else
00293    char c;
00294 #endif
00295 
00296    N = sizeF(naFin);
00297    Fin = fopen(naFin, "r");
00298    if( Fin==NULL )
00299    {
00300       perror(naFin);
00301       exit(-1);
00302    }
00303    Fout = fopen(naFout, "w");
00304    for(i=0; i<N; i=i+1)
00305    {
00306       fread(&c,1,1,Fin);
00307       M0 = (int)c;
00308       P  = pmod(M0,e,n);
00309 #if RSA_HEX
00310       sprintf(str,"%08x",P);
00311       fwrite(str,8,1,Fout);
00312 #else
00313       fwrite(&P,sizeof(int),1,Fout);
00314 #endif
00315    }
00316    fclose(Fout);
00317    fclose(Fin);
00318 }

int NWD ( int  p,
int  q 
)

Najwiekszy Wspolny Dzielnik

Popularny algorytm Euklidesa

Definicja w linii 149 pliku MyLib.c.

Odwołania w genKluczeRSA().

00150 {
00151    int r;
00152 
00153    if( p<1 || q<1 )
00154    {
00155       puts("Ups ...");
00156       exit(-1);
00157    }
00158    for(r=p%q; r!=0; r=p%q)
00159    {
00160       p = q;
00161       q = r;
00162    }
00163    return q;
00164 }

int NWDr ( int  p,
int  q,
int *  x,
int *  y 
)

rozszerzony algorytm Euklidesa: $p*x+q*y=\mathop{\mathrm{NWD}}(p,q)$

Definicja w linii 169 pliku MyLib.c.

Odwołania w genKluczeRSA().

00170 {
00171    int r,t,xp,xr,yp,yr;
00172 
00173    if( p<1 || q<1 )
00174    {
00175       puts("Ups ...");
00176       exit(-1);
00177    }
00178    xp = *y = 1;
00179    *x = yp = 0;
00180    for(r=p%q; r!=0; r=p%q)
00181    {
00182       t  = p/q;
00183       p  = q;
00184       q  = r;
00185       xr = *x;
00186       *x = xp - t*xr;
00187       xp = xr;
00188       yr = *y;
00189       *y = yp - t*yr;
00190       yp = yr;
00191    }
00192    return q;
00193 }

void OdczytMacierzy ( const char *  NazwaPliku,
int *  n,
int *  m,
double  a[][matrix_M] 
)

Definicja w linii 39 pliku MyLib.c.

Odwołania w main().

00040 {
00041     FILE *fPlik;
00042     int i,j;
00043 
00044     fPlik = fopen(NazwaPliku,"r");
00045     fscanf(fPlik,"%i", n);
00046     fscanf(fPlik,"%i", m);
00047     for(i=0; i<*n; i=i+1)
00048     {
00049         for(j=0; j<*m; j=j+1)
00050         {
00051             fscanf(fPlik,"%lf",&a[i][j]);
00052         }
00053     }
00054     fclose(fPlik);
00055 }

int parserCSV ( char *  buf,
char *  ws[],
int  n,
const char *  delim 
)

Obsluguje formaty Excel-CSV oraz TSV (ISO-8859-2)

Definicja w linii 67 pliku MyLib.c.

Odwołania w readCSV().

00068 {
00069     int i;
00070 
00071     ws[0] = buf;
00072     for(i=1; i<=n; i=i+1)
00073     {
00074         ws[i] = strpbrk(ws[i-1], delim);
00075         if( ws[i]==NULL)
00076             break;
00077         *ws[i] = '\0';
00078         ws[i]  = ws[i]+1;
00079     }
00080     return i-1;
00081 }

int pmod ( int  b,
int  e,
int  m 
)

naiwna potega $b^e \mathop{\mathrm{mod}} m$

Definicja w linii 198 pliku MyLib.c.

Odwołania w deKryptFile() i kryptFile().

00199 {
00200    int c;
00201 
00202    for(c=1; 1<=e; e=e-1)
00203    {
00204       c = (c*b)%m;
00205    }
00206    return c;
00207 }

void readCSV ( char *  nazwaCSV,
int *  N,
struct TLst  Lst[] 
)

Definicja w linii 83 pliku MyLib.c.

Odwołuje się do TLst::Ocena, parserCSV(), separator i sepStr.

00084 {
00085     char buf[1024],*wr,*ws[32],*wt[3];
00086     FILE *fDane;
00087     int i,n;
00088 
00089     fDane = fopen(nazwaCSV, "r");
00090     *N = 0;
00091     n = 3;
00092     if( fDane==NULL )
00093     {
00094         perror(nazwaCSV);
00095         exit(-1);
00096     }
00097     printf("z pliku \"%s\"", nazwaCSV);
00098     while( fgets(buf,1024,fDane)!=NULL )
00099     {
00100 /* tu mozemy sprawdzic co jest wczytywane
00101         printf(">%s<\n",buf);
00102 */
00103         if( parserCSV(buf, ws, n, separator)!=n )
00104             continue;
00105         for(i=0; i<n; i=i+1)
00106         {
00107             if( parserCSV(ws[i], wt, 2, sepStr)==2 )
00108             {
00109                 switch( i )
00110                 {
00111                     case 0:
00112                         strcpy(Lst[*N].Im, wt[1]);
00113                      break;
00114                     case 1:
00115                         strcpy(Lst[*N].Na, wt[1]);
00116                      break;
00117                     default:
00118                         puts("ERROR: zly rekord !?");
00119                      break;
00120                 }
00121             }
00122             else
00123             {
00124                 wr = strchr(ws[i],',');
00125                 if( wr!=NULL)
00126                     *wr = '.';
00127                 Lst[*N].Ocena = atof(ws[i]);
00128             }
00129         }
00130         *N = *N+1;
00131     }
00132     fclose(fDane);
00133 }

int sizeF ( const char *  naF  ) 

wyznaczenie wielkosci pliku w bajtach

Parametry:
naF nazwa pliku

Definicja w linii 269 pliku MyLib.c.

Odwołania w deKryptFile(), kryptFile() i sprRSA().

00270 {
00271    struct stat sb;
00272 
00273    if( stat(naF, &sb)==-1 )
00274    {
00275       perror(naF);
00276       exit(-1);
00277    }
00278    return (int)sb.st_size;
00279 }

int sprRSA ( const char *  naF1,
const char *  naF2 
)

sprawdzenie identycznosci plikow

Definicja w linii 363 pliku MyLib.c.

Odwołuje się do sizeF().

00364 {
00365    FILE *F1,*F2;
00366    unsigned char c1,c2;
00367    int i,n;
00368 
00369    n = sizeF(naF1);
00370    if( n!=sizeF(naF2) )
00371    {
00372       return -1;
00373    }
00374    F1 = fopen(naF1,"r");
00375    F2 = fopen(naF2,"r");
00376    for(i=0; i<n; i=i+1)
00377    {
00378       fread(&c1,1,1,F1);
00379       fread(&c2,1,1,F2);
00380       if( c1!=c2)
00381          break;
00382    }
00383    fclose(F2);
00384    fclose(F1);
00385    return (i!=n ? -2 : 0 );
00386 }

int testPodziel ( int  n  ) 

sprawdzam, czy liczba $n$ jest pierwsza

bardziej zaawansowane metody testowania: Test AKS   (The AKS primality test)

Definicja w linii 216 pliku MyLib.c.

Odwołania w genKluczeRSA().

00217 {
00218    int i,m;
00219 
00220    m = n/2;
00221    for(i=2; i<m && n%i ; i=i+1)
00222       ;
00223    return (int)(i<m);
00224 }

void WyswietlMacierz ( int  n,
int  m,
double  a[][matrix_M] 
)

Definicja w linii 8 pliku MyLib.c.

Odwołania w main().

00009 {
00010     int i,j;
00011 
00012     for(i=0; i<n; i=i+1)
00013     {
00014         for(j=0; j<m; j=j+1)
00015         {
00016             printf("%6.2lf ",a[i][j]);
00017         }
00018         printf("\n");
00019     }
00020 }

void ZapisMacierzy ( char *  NazwaPliku,
int  n,
int  m,
double  a[][matrix_M] 
)

Definicja w linii 22 pliku MyLib.c.

00023 {
00024     FILE *fPlik;
00025     int i,j;
00026 
00027     fPlik = fopen(NazwaPliku,"w");
00028     fprintf(fPlik,"%i\n%i\n",n,m);
00029     for(i=0; i<n; i=i+1)
00030     {
00031         for(j=0; j<m; j=j+1)
00032         {
00033             fprintf(fPlik,"%4.2lf\n",a[i][j]);
00034         }
00035     }
00036     fclose(fPlik);
00037 }

Dokumentacja zmiennych

const int matrix_M = 25

maksymalna ilosc kolumn w macierzy

Definicja w linii 6 pliku MyLib.c.

Odwołania w main().

const int matrix_N = 25

maksymalna ilosc wierszy w macierzy

Definicja w linii 5 pliku MyLib.c.

Odwołania w main() i ObliczWyznacznik().

const char rsa_naFcrp[] = "_MyLib.crp"

zaszyfrowany plik

Definicja w linii 141 pliku MyLib.c.

const char rsa_naFin[] = "_MyLib.c"

plika do zaszyfrowania

Definicja w linii 140 pliku MyLib.c.

const char rsa_naFres[] = "_MyLib.res"

plik odszyfrowany

Definicja w linii 142 pliku MyLib.c.

const int rsa_p = 61

liczba pierwsza potrzebna w algorytmie RSA

Definicja w linii 137 pliku MyLib.c.

const int rsa_q = 53

liczba pierwsza potrzebna w algorytmie RSA

Definicja w linii 138 pliku MyLib.c.

const char separator[] = ";\r\t\n"

Definicja w linii 59 pliku MyLib.c.

Odwołania w readCSV().

const char sepStr[] = "\""

Definicja w linii 60 pliku MyLib.c.

Odwołania w readCSV().

Wygenerowano Fri Dec 18 10:26:36 2009 dla WIP w IM UWr. programem  doxygen 1.5.8