криптография. метод шифрования- Алгебраические методы (матрица*вектор_столбец), объект-пароли в файле паролей

int N = 3;
double round(double d)
{
   double id = int(d);
   return (d<0) ? ((id - d < 0.5) ? id : id-1) : ((d - id < 0.5) ? id : id+1);
}
AnsiString code(AnsiString text)
{
    int i,j=1,m,k,jj;
    double buf1,buf2;
    AnsiString cod;
//---------------------------------------------------------------------------
    double **KEY=new double *[N];
    for(i=0;i<N;i++)
        KEY[i]=new double [N];
    for(i=0;i<N;i++)
        for(j=0;j<N;j++)
            KEY[i][j]=StrToFloat(Form1->StringGrid1->Cells[j][i]);
//---------------------------------------------------------------------------
    if(text.Length()<N)
   {
        for(i=0;i<=(N-text.Length());i++)
        text+=" ";
   }
    if((text.Length()%N)!=0)
   {
        for(i=0;i<=(text.Length()%N);i++)
        text+=" ";
   }
//---------------------------------------------------------------------------
    i=0;m=1;k=1;jj=0;j=0;
    //шифрование текста
    buf2=0;
    buf1=0;
    while(i<text.Length())
    {
        buf2=text[m]+128;
        buf1+=KEY[jj][j]*buf2;
        jj++;m++;
        if(jj==N)
            {jj=0;m=k;i++;cod+=FloatToStr(buf1)+' ';buf1=0;j++;
            if(j==N)
                {j=0;k=i;m=k;}}
    }
return cod;
}
AnsiString decode(AnsiString text)
{
int i,j,m,n,k,jj;double buf1;
AnsiString name,mes,cod,buf;
bool tx=false;
double **KEY=new double *[N];
    for(i=0;i<N;i++)
        KEY[i]=new double [N];
for(i=0;i<N;i++)
    for(j=0;j<N;j++)
        KEY[i][j]=StrToFloat(Form1->StringGrid1->Cells[i][j]);
//---------------------------------------------------------------------------
for(i=0;i<text.Length();i++)
{
    if(text[i]==':'&&text[i+1]==' ')
        {name+=text[i];name+=" ";tx=true;i+=2;}
    if(tx)
    {
        mes+=text[i];
    }
    else name+=text[i];
}
//---------------------------------------------------------------------------
m=0;
for(i=1;i<text.Length();i++)
{
 if(mes[i]==' ') m++;
}
double *MES=new double [m];
cod.SetLength(m);
m=0;
for(i=1;i<=mes.Length();i++)
{
 if(mes[i]==' ')
    {MES[m]=StrToFloat(buf);m++;buf.SetLength(0);}
 else
    buf+=mes[i];
}
 
//---------------------------------------------------------------------------
double **L=new double *[N];
    for(i=0;i<N;i++)
        L[i]=new double [N];
    for (i=0; i<N; i++)
        for (j=0; j<N; j++)
            if (i!=j)
                L[i][j]=0;
            else L[i][j]=1;
 
 j = 0;
 
do
  { // Выбор ведущего элемента ниже элемента [j,j-1]:
    m = j;
    for (n=j+1; n<N; n++)
      if (fabs(KEY[m][j])<fabs(KEY[n][j])) m = n;
    double prm=0;
 
 
    //Переобразования над матрицой:
    for (n=0; n<N; n++)
    { prm = KEY[m][n];
      KEY[m][n] = KEY[j][n];
      KEY[j][n] = prm;
      prm = KEY[m][n];
      KEY[m][n] = KEY[j][n];
      KEY[j][n] = prm;
    }
 
    prm = KEY[j][j];
    for (n=0; n<N; n++)
    { KEY[j][n] = double (KEY[j][n]/prm);
      L[j][n] = double (L[j][n]/prm);
    }
    for (i=0; i<N; i++)
      if (i!=j)
      { prm = KEY[i][j];
    for (n=j; n<N; n++) KEY[i][n] = KEY[i][n]- double (prm*KEY[j][n]);
    for (n=0; n<N; n++) L[i][n] =L[i][n]- double (prm*L[j][n]);
      }
    j++;
    }
  while (j<N);
 
  /*for (i=0;i<N;i++)
  for (j=0;j<N;j++)
  L[i][j]=round(L[i][j]);*/
  for(i=0;i<N;i++)
  for(j=0;j<N;j++)
  Form1->StringGrid2->Cells[i][j]=FloatToStr(L[i][j]);
 
 
    for(i=1;i<=cod.Length();i++)
    cod[i]=0;
    i=1;m=0;k=0;jj=0;j=0;
    buf1=0;
    //расшифрование текста
    while(i<=cod.Length())
    {
     buf1+=L[jj][j]*MES[m];
     jj++;m++;
     if(jj==N)
     {jj=0;m=k;cod[i]=(round(buf1)-128);buf1=0;i++;j++;
      if(j==N)
       {j=0;k=i-1;m=k;}}
    }
 
 
delete KEY;
delete L;
delete MES;
return name+cod;
}
bool test()
{
int i,j,n,m,k;
double max,f,s;
 
for(i=0;i<N;i++)
    for(j=0;j<N;j++)
        if (Form1->StringGrid1->Cells[j][i].Length()==0) {ShowMessage("Ошибка обработки матрицы");return false;}
 
double **KEY=new double *[N];
    for(i=0;i<N;i++)
        KEY[i]=new double [N];
        //double KEY[3][3];
for(i=0;i<N;i++)
    for(j=0;j<N;j++)
        KEY[i][j]=StrToFloat(Form1->StringGrid1->Cells[j][i]);
 
 for (n=0;n<N;n++) //прямой ход Гаусса, приведение матрицы коэффициентов к треугольному виду
     {
       for (m=n+1;m<N;m++)
          {
 
             max=KEY[n][n];i=n;
             for (k=n;k<N;k++)
              {
                if (KEY[n][k]>max) {max=KEY[n][k];i=k;}
              }
 
              if ((max!=0)&&(i!=n))
               {
               for (k=0;k<N;k++)
                {
                 f=KEY[k][i];
                 KEY[k][i]=KEY[k][n];
                 KEY[k][n]=f;
                }
               }
 
 
          if(KEY[n][n]!=0)
          {s=KEY[m][n]/KEY[n][n];}
          else
          {ShowMessage("Ошибка обработки матрицы");return false;}
 
            for (k=n;k<N;k++)
               {
                 f=KEY[m][k]-(s*KEY[n][k]);
                 if ((f<0.0000001)&&(f>0))f=0;
                 KEY[m][k]=f;
               }
          }
     }
     s=KEY[0][0];
     for(i=1;i<N;i++)
     {
      s=s*KEY[i][i];
     }
     if(s==0){ShowMessage("Ошибка обработки матрицы");return false;}
     else
     delete KEY;
     return true;
 
}