Документация по криптоалгоритмам / GOST-28147-89 / GOST_UTI / MAKEKEYS

/*----------------------------------------------------
  MakeKeys.c -- Ёб室­л©  ⥪бв  Їа®Ја ¬¬л ўла Ў®вЄЁ
		¬ ббЁў  Є«о祢®© Ё­д®а¬ жЁЁ.
  ----------------------------------------------------
  ђ §а Ў®в « Ђ.ћ.‚Ё­®Єга®ў, Ј.Њ®бЄў , п­ў ам 1995 Ј.
  (c) 1995, ‘ў®Ў®¤­®Ґ  ЁбЇ®«м§®ў ­ЁҐ  Ё Є®ЇЁа®ў ­ЁҐ.
  ----------------------------------------------------
  ќв  Їа®Ја ¬¬  бЇҐжЁ «м­® б®бв ў«Ґ­  ¤«п ЇгЎ«ЁЄ жЁЁ
  ў "Њ®­Ёв®аҐ".
  ----------------------------------------------------
*/
#include <io.h>		// open, filelength
#include <fcntl.h>	// O_RDONLY
#include <ctype.h>	// toupper,isdigit
#include <stdlib.h>	// strtoul
#include <stdio.h>	// printf
#include <dir.h>	// MAXPATH
#include <memory.h>	// setmem
#include <string.h>	// strlen
#include "gost.h"	// „ ­­лҐ Ё Їа®в®вЁЇл ѓЋ‘’ 
// а §¬Ґа ЎгдҐа  ®Ў¬Ґ­  - ¤®«¦Ґ­ Ўлвм Єа вҐ­ 8
#define  BUFFER_SIZE    8192

// ѓ«®Ў «м­лҐ бв вЁзҐбЄЁҐ ¤ ­­лҐ

extern unsigned _stklen=BUFFER_SIZE+4096; // а §¬Ґа бвнЄ 

typedef enum
{
  O_K_=0,	    // ўбҐ O.K.
  errInvalidFlag,   // ­ҐўҐа­л© д« Ј ўл§®ў  Їа®Ја ¬¬л
  errBadSynchro,    // ­ҐўҐа­® § ¤ ­  бЁ­еа®Ї®бл«Є 
  errBadDefault,    // ­ҐўҐа­® § ¤ ­  бЁ­еа®Ї®бл«Є 
  errNoParm,	    // ®вбгвбвўгов Ї а ¬Ґвал ўл§®ў 
  errBadKey,	    // Ї«®е®© д ©« Є«оз 
  errBadXCHT,	    // Ї«®е®© д ©« б в Ў«ЁжҐ© § ¬Ґ­
  errListFailure,   // ®иЁЎЄ  ­  д ©«Ґ-бЇЁбЄҐ
  errBadKeyLength,  // ­ҐўҐа­® § ¤ ­  ¤«Ё­  Є«оз 
  errZeroKeyLength, // § ¤ ­  ­г«Ґў п ¤«Ё­  Є«оз 
  errKeyFailure     // ®иЁЎЄ  ­  д ©«Ґ б Є«о箬
} errList;

unsigned char chtab[1024];

Item	Key[32];	// а §ўҐа­гвл© Є«оз

Item    Synchro[2]=	// бЁ­еа®Ї®бл«Є 
{
  0UL,0UL
};

errList code=O_K_;	// Є®¤ ўл室 

int	ParmCount= 0;   // бзҐвзЁЄ Ї а ¬Ґва®ў
static unsigned
  ListProcessed=0,      // бзҐвзЁЄ Ї а ¬Ґва®ў
  KeyMade=0,            // бзҐвзЁЄ Є«о祩
  DefaultLen=32;	// ¤«Ё­  Є«оз  Ї® 㬮«з ­Ёо

unsigned char Buffer[BUFFER_SIZE],
	      *BufferPtr=Buffer+BUFFER_SIZE;

// Џа®в®вЁЇл дг­ЄжЁ©

errList ProcessKey	(char *parameter);
errList ProcessItem	(char *parameter);
errList	SignalError     (errList errType,
			 char *errPlace);
errList loadCht		(char *chtFile);
errList loadKey		(char *keyFile);
errList	execute		(void);

// ѓ« ў­ п Їа®Ја ¬¬  ¬®¤г«п

errList	main(int argc, char *argv[])
{
  unsigned short i;

  printf("Џа®Ја ¬¬  ўла Ў®вЄЁ Є«о祩 б Ї®¬®ймо "
	 "ЄаЁЇв®Ја дЁзҐбЄ®Ј®  «Ј®аЁв¬  ѓЋ‘’ 28147-89\n"
	 "‘®бв ўЁ« Ђ.ћ.‚Ё­®Єга®ў, п­ў ам 1995 Ј®¤ ,"
	 " бў®Ў®¤­®Ґ ЁбЇ®«м§®ў ­ЁҐ Ё Є®ЇЁа®ў ­ЁҐ\n");

  if (argc==1)
    printf(
"Љ®¬ ­¤  § ЇгбЄ :  \"makekeys [Є«озЁ] бЇЁбЄЁ [[Є«озЁ]"
	" бЇЁбЄЁ]...\"         ,Ј¤Ґ:\n"
"  Є«озЁ - нв® ®¤Ё­ Ё«Ё ­ҐбЄ®«мЄ® б«Ґ¤гойЁе"
	" н«Ґ¬Ґ­в®ў:\n"
"    /K<д ©«> - § ¤ Ґв д ©« б Є«о箬, §¤Ґбм Ё ¤ «ҐҐ"
	" <д ©«> - нв® ¤®ЇгбвЁ¬®Ґ\n"
"             ў MS-DOS Ё¬п д ©« .\n"
"             „«Ё­  д ©«  б Є«о箬 ¤®«¦­  Ўлвм "
	"32 Ё«Ё 256 Ў ©в®ў\n"
"             Џ® 㬮«з ­Ёо ЁбЇ®«м§гҐвбп ваЁўЁ «м­л©"
	" ­г«Ґў®© Є«оз.\n"
"    /C<д ©«> - § ¤ Ґв д ©« б в Ў«ЁжҐ© § ¬Ґ­"
	" ¤«Ё­®© - 256 Ё«Ё 1024 Ў ©в \n"
"             Џ® 㬮«з ­Ёо ЁбЇ®«м§гҐвбп ваЁўЁ «м­ п"
	" в Ў«Ёж  § ¬Ґ­.\n"
"    /SXXXX - § ¤ Ґв бЁ­еа®Ї®бл«Єг, §¤Ґбм XXXX - "
	"8(Ё«Ё ¬Ґ­миҐ)-а §ап¤­®Ґ\n"
"             16-аЁз­®Ґ 楫®Ґ ЎҐ§ §­ Є  Ё ¬ аЄҐа®ў"
	" ®б­®ў ­Ёп\n"
"             Џ® 㬮«з ­Ёо ЁбЇ®«м§гҐвбп ­г«Ґў п"
	" бЁ­еа®Ї®бл«Є .\n"
"    /LNNNN - § ¤ Ґв ¤«Ё­г Є«оз  Ї® 㬮«з ­Ёо - §¤Ґбм "
	"NNNN - ¤ҐбпвЁз­®Ґ 楫®Ґ\n"
"             ЎҐ§ §­ Є , Ґб«Ё Ї а ¬Ґва ­Ґ § ¤ ­ пў­®,"
	" бзЁв Ґвбп а ў­л¬ 32\n"
"  бЇЁбЄЁ - нв® ®¤­® Ё«Ё ­ҐбЄ®«мЄ® а §¤Ґ«Ґ­­ле"
	" Їа®ЎҐ« ¬Ё Ё¬Ґ­ д ©«®ў,\n"
"  пў«пойЁебп бЇЁбЄ ¬Ё ®ЇЁб вҐ«Ґ© Є«о祩.  Љ ¦¤л© "
	"бЇЁб®Є ᮤҐа¦Ёв бва®ЄЁ\n"
"  Є®¬¬Ґ­в аЁҐў, ­ зЁ­ ойЁҐбп б в®зЄЁ б § Їпв®© Ё«Ё"
	" Їа®ЎҐ«м­®Ј® бЁ¬ў®« ,\n"
"  Ё бва®ЄЁ ®ЇЁб вҐ«Ґ© Є«оз , Ё¬ҐойЁҐ б«Ґ¤гойЁ©"
	" д®а¬ в:\n"
"  <д ©«> [¤«Ё­ ]\n"
"  Ј¤Ґ д ©« Ё ¤«Ё­  - Ё¬п Ё а §¬Ґа д ©«   ¤«п § ЇЁбЁ"
	" Є«оз ,  ¤«Ё­  § ЇЁблў Ґвбп\n"
"  ў ¤ҐбпвЁз­®© бЁб⥬Ґ, Ї® 㬮«з ­Ёо а ў­  §­ зҐ­Ёо,"
	" § ¤ ­­®¬г Є«о箬 /L\n"
  );
  else
  {
// ќв®в жЁЄ« бва®Ёв ваЁўЁ «м­го в Ў«Ёжг § ¬Ґ­
// “¤ «ЁвҐ ҐЈ®, Ґб«Ё Ўг¤ҐвҐ Ё­ЁжЁ «Ё§Ёа®ў вм  chtab
    for (i=0; i<1024; i++) chtab[i]=i;

// жЁЄ« Їа®б¬®ва  Є®¬ ­¤­®© бва®ЄЁ
    while (*++argv)
      if (
	(code=(**argv=='/' ? ProcessKey : ProcessItem)
		   (*argv))   != O_K_)
	break;

    printf("KeyMaker: ЋЎа Ў®в ­® %d бЇЁбЄ®ў,"
	" ᤥ« ­® %d Є«о祩\n",ListProcessed,KeyMade);

    return code;
  }
  return O_K_;
}

// ®Ўа Ў®вЄ  Є«о祩 [/x...] Є®¬ ­¤­®© бва®ЄЁ

errList	ProcessKey(char *parameter)
{
  char *c;

  ++parameter;
  switch (toupper(*(parameter++)))// ўлЎ®а Ї® ЎгЄўҐ
  {
    case 'K':
      if(loadKey(parameter) != O_K_)
	return errBadKey;
      break;
    case 'C':
      if (loadCht(parameter) != O_K_)
	return errBadXCHT;
      break;
    case 'S':
      if (strlen(parameter)==0 ||
	 (Synchro[0]=strtoul(parameter,&c,16),*c))
	return SignalError(errBadSynchro,parameter);
      break;
    case 'L':
      if (strlen(parameter)==0 ||
	 (DefaultLen=strtoul(parameter,&c,10),*c))
	return SignalError(errBadDefault,parameter);
      break;
    default:
      return  SignalError(errInvalidFlag,parameter-2);
  }
  return O_K_;
}

// гбв ­®ўЄ  ०Ё¬®ў б®Ј« б­® д« Ј ¬ ўл§®ў 

errList	ProcessItem(char *parameter)
{
  FILE *KeyList,*KeyFile;

// ђ Ў®в Ґ¬ б® бЇЁбЄ®¬ д ©«®ў-Є«о祩
  if ((KeyList=fopen(parameter,"rt"))==NULL)
    return SignalError(errListFailure,parameter);
  else
  {
    unsigned char buffer[MAXPATH+10],*p;

    while (fgets(buffer,MAXPATH+10,KeyList))
      if (*buffer>' ' && *buffer!=';')
      {
	unsigned short KeyLength=DefaultLen;
	for (p=buffer; *p > ' ' && *p != ';'; p++);
	if (*p==';') *p=0;
	else if(*p)
	{
	  *p=0;
	  while(*++p && *p<=' ');
	  if(isdigit(*p))
	    KeyLength=atoi(p);
	  else if( *p && *p != ';')
	    return SignalError(errBadKeyLength,p);
	}
	if(KeyLength==0)
	  return SignalError(errZeroKeyLength,NULL);
	if((KeyFile=fopen(buffer,"wb"))==NULL)
	  return SignalError(errKeyFailure,buffer);
	while(KeyLength)
	{
	  unsigned short register QuantSize;

	  if(BufferPtr-Buffer>=BUFFER_SIZE)
	    gamme(Key,Synchro,chtab,BufferPtr=Buffer,
		   BUFFER_SIZE/sizeof(CrBlock));
	  QuantSize=(KeyLength > BUFFER_SIZE ?
			      BUFFER_SIZE : KeyLength);

	  if(fwrite(BufferPtr,1,QuantSize,KeyFile) <
	      QuantSize)
	    return fclose(KeyFile),
		      SignalError(errKeyFailure,buffer);
	  KeyLength-=QuantSize;
	  BufferPtr+=QuantSize;
	}
      if (fclose(KeyFile))
	return SignalError(errKeyFailure,buffer);
      KeyMade++;
      }
  }
  ListProcessed++;
  return O_K_;
}

// ‡ Јаг§Є  в Ў«Ёжл § ¬Ґ­

errList loadCht(char *ChtFile)
{
  int	handle;
  unsigned long  FileSize;
  unsigned char  buffer[128];

  if ((handle=open(ChtFile,O_RDONLY))==-1 ||
       ((FileSize=filelength(handle)) != 128 &&
			      FileSize != 1024) ||
    read(handle,
      FileSize==128 ? buffer : chtab,FileSize)==-1)
    return errBadKey;

  if (FileSize == 128) ExpCht(buffer,chtab);
  close(handle);
  return O_K_;
}

// ‡ Јаг§Є  Є«оз 

errList loadKey(char *KeyFile)
{
  int	handle,FileSize;
  unsigned char  buffer[32];

  if ((handle=open(KeyFile,O_RDONLY))==-1 ||
       ((FileSize=filelength(handle)) != 32 &&
			      FileSize != 128) ||
	  read(handle, FileSize==32 ?
            (void*) buffer : (void*) Key, FileSize)==-1)
    return errBadKey;

  if (FileSize==32) ExpKey31(buffer,Key);
  close(handle);
  return O_K_;
}

// ‚л¤ з  б®®ЎйҐ­Ёп ®Ў ®иЁЎЄҐ

errList	SignalError(errList errType, char *errPlace)
{
  char *errText[]=
  {
  "ЌҐўҐа­л© д« Ј ўл§®ў  Їа®Ја ¬¬л - %s\n",
  "ЌҐўҐа­® § ¤ ­  бЁ­еа®Ї®бл«Є  - %s\n",
  "ЌҐўҐа­® § ¤ ­  ¤«Ё­  Є«оз  Ї® 㬮«з ­Ёо - %s\n",
  "Ћвбгвбвўгов Ї а ¬Ґвал-бЇЁбЄЁ д ©«®ў Є«о祩\n",
  "ЌҐўҐа­® § ¤ ­ д ©« б Ёб室­л¬ Є«о箬 - %s\n",
  "ЌҐўҐа­® § ¤ ­ д ©« б в Ў«ЁжҐ© § ¬Ґ­ - %s\n",
  "ЋиЁЎЄ  ­  д ©«Ґ б® бЇЁбЄ®¬ д ©«®ў-Є«о祩 - %s\n",
  "ЌҐЇ®­пв­л© н«Ґ¬Ґ­в ў¬Ґбв® ¤«Ё­л Є«оз  - %s\n",
  "‡ ¤ ­  ­г«Ґў п ¤«Ё­  Є«оз , зв® ­Ґ¤®ЇгбвЁ¬®\n",
  "ЋиЁЎЄ  ЇаЁ ®вЄалвЁЁ/§ ЇЁбЁ д ©«  б Є«о箬 - %s\n"
  };
  printf(errText[errType-1],errPlace);
  return errType;
}