--- dn_ORIG.c   2016-08-22 11:40:58.000000000 +0300
+++ dn.c        2018-06-26 19:23:38.068492230 +0300
@@ -48,6 +48,7 @@
                  2 = David Chadwick, July 2003
                  <draft-ietf-pkix-dnstrings-02.txt>
                  3 = Peter Gutmann
+                 4 = tk26
               */
   const char *description;
   size_t      oidlen;
@@ -74,12 +75,17 @@
     "\x09\x92\x26\x89\x93\xF2\x2C\x64\x01\x19", "0.9.2342.19200300.100.1.25" },
 {"UID", 1, "userid",              10,
     "\x09\x92\x26\x89\x93\xF2\x2C\x64\x01\x01", "0.9.2342.19200300.100.1.1 " },
-{"EMAIL", 3, "emailAddress",       9,
+{"E", 1, "emailAddress",       9,
     "\x2A\x86\x48\x86\xF7\x0D\x01\x09\x01",     "1.2.840.113549.1.9.1" },
+/*oid-ы квалифицированного сертификата от TK-26*/
+{"OGRN", 4, "OGRN",             5, "\x2a\x85\x03\x64\x01", "1.2.643.100.1" },
+{"INN", 4, "INN",             8, "\x2a\x85\x03\x03\x81\x03\x01\x01", "1.2.643.3.131.1.1" },
+{"SNILS", 4, "SNILS",             5, "\x2a\x85\x03\x64\x03", "1.2.643.100.3" },
+{"OGRNIP", 4, "OGRNIP",             5, "\x2a\x85\x03\x64\x05", "1.2.643.100.5" },
+
 { NULL }
 };
 
-
 #define N 0x00
 #define P 0x01
 static unsigned char charclasses[128] = {
@@ -555,8 +561,8 @@
   name = NULL;
   for (i=0; oid_name_tbl[i].name; i++)
     {
-      if (oid_name_tbl[i].source == 1
-          && node->len == oid_name_tbl[i].oidlen
+/*Все oid-ы из DN переводим в текстовую форму*/
+      if (node->len == oid_name_tbl[i].oidlen
           && !memcmp (image+node->off+node->nhdr,
                       oid_name_tbl[i].oid, node->len))
         {
@@ -604,6 +610,9 @@
     case TYPE_UTF8_STRING:
       append_utf8_value (image+node->off+node->nhdr, node->len, sb);
       break;
+/*Добавляем обработку NUMERIC_STRING*/
+    case TYPE_NUMERIC_STRING:
+
     case TYPE_PRINTABLE_STRING:
     case TYPE_IA5_STRING:
       /* we assume that wrong encodings are latin-1 */

--- keyinfo_ORIG.c	2015-10-28 13:41:48.000000000 +0300
+++ keyinfo.c	2018-06-29 10:22:38.312284306 +0300
@@ -45,7 +45,6 @@
 #include "convert.h"
 #include "ber-help.h"
 
-
 /* Constants used for the public key algorithms.  */
 typedef enum
   {
@@ -98,6 +97,19 @@
     "1.2.840.10045.2.1", /*  ecPublicKey */
     "\x2a\x86\x48\xce\x3d\x02\x01", 7,
     1, PKALGO_ECC, "ecc", "q", "\x80" },
+/*oid-ы ГОСТ-овых ключей*/
+  { /* GOST3410-2001 */
+    "1.2.643.2.2.19", /*  gostPublicKey-2001 */
+    "\x2a\x85\x03\x02\x02\x13", 6,
+    1, PKALGO_ECC, "ecc", "q", "\x80" },
+  { /* GOST3410-2012-256 */
+    "1.2.643.7.1.1.1.1", /*  gostPublicKey-2012-256 */
+    "\x2a\x85\x03\x07\x01\x01\x01\x01", 8,
+    1, PKALGO_ECC, "ecc", "q", "\x80" },
+  { /* GOST3410-2012-512 */
+    "1.2.643.7.1.1.1.2", /*  gostPublicKey-2012-512 */
+    "\x2a\x85\x03\x07\x01\x01\x01\x02", 8,
+    1, PKALGO_ECC, "ecc", "q", "\x80" },
 
   {NULL}
 };
@@ -209,6 +221,32 @@
     "1.3.36.3.4.3.2.2",     /* sigS_ISO9796-2rndWithrsa_ripemd160 */
     "\x2B\x24\x03\x04\x03\x02\x02", 7,
     0, PKALGO_RSA, "rsa", "s", "\x82", NULL, NULL, "rmd160" },
+/*oid-ы, связанные с ГОСТ-овой подписью*/
+  { /* GOST3410-2001 */
+    "1.2.643.2.2.19", /*  gostPublicKey-2001 */
+    "\x2a\x85\x03\x02\x02\x13", 6,
+    1, PKALGO_ECC, "gost", "s", "\x80", NULL, NULL, "gostr3411_94" },
+  { /* GOST3410-2012-256 */
+    "1.2.643.7.1.1.1.1", /*  gostPublicKey-2012-256 */
+    "\x2a\x85\x03\x07\x01\x01\x01\x01", 8,
+    1, PKALGO_ECC, "gost", "s", "\x80", NULL, NULL, "stribog256"},
+  { /* GOST3410-2012-512 */
+    "1.2.643.7.1.1.1.2", /*  gostPublicKey-2012-512 */
+    "\x2a\x85\x03\x07\x01\x01\x01\x02", 8,
+    1, PKALGO_ECC, "gost", "s", "\x80", NULL, NULL, "stribog512"},
+
+  { /* GOST3411-2012-256 */
+    "1.2.643.7.1.1.3.2", /*  STRIBOG256 */
+    "\x2a\x85\x03\x07\x01\x01\x03\x02", 8,
+    1, PKALGO_ECC, "gost", "s", "\x80", NULL, NULL, "stribog256" },
+  { /* GOST3411-2012-512 */
+    "1.2.643.7.1.1.3.3", /*  STRIBOG512 */
+    "\x2a\x85\x03\x07\x01\x01\x03\x03", 8,
+    1, PKALGO_ECC, "gost", "s", "\x80", NULL, NULL, "stribog512" },
+  { /* GOST3410-2001-Signature */
+    "1.2.643.2.2.3", /*  gosrPublicKey-2001 avec signature */
+    "\x2a\x85\x03\x02\x02\x03", 6,
+    1, PKALGO_ECC, "gost", "s", "\x80", NULL, NULL, "gostr3411_94" },
 
   {NULL}
 };
@@ -218,6 +256,20 @@
     "1.2.840.113549.1.1.1", /* rsaEncryption (RSAES-PKCA1-v1.5) */
     "\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01", 9,
     1, PKALGO_RSA, "rsa", "a", "\x82" },
+/*oid-ы ГОСТ-ых ключей для ассиметричного шифрования*/
+  {
+    "1.2.643.2.2.19", /*GOST R34.10-2001 */
+    "\x2A\x85\x03\x02\x02\x13", 6,
+    1, PKALGO_ECC, "ecc", "a", "\x80" },
+  {
+    "1.2.643.7.1.1.1.1", /*GOST R34.10-2012-256 */
+    "\x2A\x85\x03\x07\x01\x01\x01\x01", 8,
+    1, PKALGO_ECC, "ecc", "a", "\x80" },
+  {
+    "1.2.643.7.1.1.1.2", /*GOST R34.10-2012-512 */
+    "\x2A\x85\x03\x07\x01\x01\x01\x02", 8,
+    1, PKALGO_ECC, "ecc", "a", "\x80" },
+
   {NULL}
 };
 
@@ -267,6 +319,13 @@
     { "1.2.643.2.2.35.1",    "GOST2001-CryptoPro-A" },
     { "1.2.643.2.2.35.2",    "GOST2001-CryptoPro-B" },
     { "1.2.643.2.2.35.3",    "GOST2001-CryptoPro-C" },
+/*дополнительные oid-ы точек эллиптической кривой для ГОСТ Р 34.10-2001/2012*/
+//    "GOST2001-CryptoPro-XchA" 
+    { "1.2.643.2.2.36.0", "GOST2001-CryptoPro-A" }, 
+//    "GOST2001-CryptoPro-XchB" 
+    { "1.2.643.2.2.36.1", "GOST2001-CryptoPro-C" }, 
+
+
     { "1.2.643.7.1.2.1.2.1", "GOST2012-tc26-A"      },
     { "1.2.643.7.1.2.1.2.2", "GOST2012-tc26-B"      },
 
@@ -393,7 +452,8 @@
   /* get the object identifier */
   if (!derlen)
     return gpg_error (GPG_ERR_INV_KEYINFO);
-  c = *der++; derlen--;
+  c = *der++;
+   derlen--;
   if ( c != 0x06 )
     return gpg_error (GPG_ERR_UNEXPECTED_TAG); /* not an OBJECT IDENTIFIER */
   TLV_LENGTH(der);
@@ -418,6 +478,7 @@
       if (!derlen)
         return gpg_error (GPG_ERR_INV_KEYINFO);
       c = *der++; derlen--;
+
       if ( c == 0x05 )
         {
           /*printf ("parameter: NULL \n"); the usual case */
@@ -471,6 +532,7 @@
       else
         {
 /*            printf ("parameter: with tag %02x - ignored\n", c); */
+
           TLV_LENGTH(der);
           seqlen -= der - startparm;
           /* skip the value */
@@ -692,6 +754,9 @@
   const unsigned char *ctrl;
   const char *elem;
   struct stringbuf sb;
+/*LISSI*/
+  int gost_key;
+  char *parm_oid_hash = NULL;
 
   *r_string = NULL;
 
@@ -701,6 +766,7 @@
   c = *der++; derlen--;
   if ( c != 0x30 )
     return gpg_error (GPG_ERR_UNEXPECTED_TAG); /* not a SEQUENCE */
+
   TLV_LENGTH(der);
   /* and now the inner part */
   err = get_algorithm (1, der, derlen, &nread, &off, &len, &is_bitstr,
@@ -715,13 +781,36 @@
            && !memcmp (der+off, pk_algo_table[algoidx].oid, len))
         break;
     }
+
   if (!pk_algo_table[algoidx].oid)
     return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
   if (!pk_algo_table[algoidx].supported)
     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
+/*Определяем тип ключа 1 - ГОСТ-овый ключ*/
+  gost_key = !memcmp(pk_algo_table[algoidx].oidstring, "1.2.643", 7);
 
   if (parm_off && parm_len && parm_type == TYPE_OBJECT_ID)
     parm_oid = ksba_oid_to_str (der+parm_off, parm_len);
+  else 
+/*Извлекаем параметры ГОСТ-ового ключа*/
+  if (parm_off && parm_len && parm_type == TYPE_SEQUENCE && gost_key && (*(der+parm_off + off - 2) == TYPE_OBJECT_ID)){
+/*Вытаскиваем oid curve для ГОСТ-ключа*/
+    int len_hash;
+    int len_curve;
+    unsigned char* addr_hash;
+    unsigned char* addr_curve;
+    len_curve = (int) *(der+parm_off + off -1);
+    addr_curve = der+parm_off + off;
+    parm_oid = ksba_oid_to_str (addr_curve, len_curve);
+/*Вытаскиваем oid хэша для ГОСТ-ключа*/
+    if( *(addr_curve + len_curve)== TYPE_OBJECT_ID) {
+	len_hash = (unsigned int) *(der+parm_off + off + len_curve + 1);
+	addr_hash = addr_curve + len_curve + 2;
+	parm_oid_hash = ksba_oid_to_str (addr_hash, len_hash);
+    }
+/*Вытаскиваем oid алгоритма шифрования для ГОСТ-ключа*/
+  }
+
   else if (parm_off && parm_len)
     {
       parmder = der + parm_off;
@@ -762,6 +851,13 @@
       put_stringbuf_sexp (&sb, "curve");
       put_stringbuf_sexp (&sb, parm_oid);
       put_stringbuf (&sb, ")");
+/*Устанавливаем oid-хэша для ГОСТ-ового ключа*/
+      if(gost_key && parm_oid_hash) {
+        put_stringbuf (&sb, "(");
+	put_stringbuf_sexp (&sb, "hash");
+        put_stringbuf_sexp (&sb, parm_oid_hash);
+        put_stringbuf (&sb, ")");
+      }
     }
 
   /* If parameters are given and we have a description for them, parse
@@ -851,6 +947,43 @@
           put_stringbuf (&sb, "(");
           tmp[0] = *elem; tmp[1] = 0;
           put_stringbuf_sexp (&sb, tmp);
+/*Извлечение значения открытого ключа в соответствии с рекомендациями TK-26*/
+          if(gost_key){
+            unsigned char pk[129];
+            unsigned char *x;
+            unsigned char *y;
+            int len_pk;
+            int len_xy;
+	    int i;
+	    unsigned char c_inv;
+	    int offset;
+            pk[0] = 0x04;
+            if(len == 131 || len == 66){
+        	offset = 0;
+    		if(der[0] == 0x04 && der[1] & 0x80)
+    		    offset = 3;
+    		else if(der[0] == 0x04 && der[1] & 0x40)
+    		    offset = 2;
+		len_pk = len - offset;
+		memcpy(&pk[1], der + offset, len_pk);
+		x = &pk[1];
+		len_xy = len_pk / 2;
+		y = x + len_xy;
+/*REVERT-INVERTIROVANIE*/
+        	for (i = 0; i < (len_xy/2); i++) {
+            	    c_inv = *(x + i);
+            	    *(x + i) = *(x + len_xy - i - 1);
+            	    *(x + len_xy - i - 1) = c_inv;
+        	}
+        	for (i = 0; i < (len_xy/2); i++) {
+            	    c_inv = y[i];
+            	    y[i] = y[len_xy - i -1];
+            	    y[len_xy - i - 1] = c_inv;
+        	}
+        	put_stringbuf_mem_sexp (&sb, pk , len_pk + 1);
+	    }
+          } else
+
           put_stringbuf_mem_sexp (&sb, der, len);
           der += len;
           derlen -= len;
@@ -1606,6 +1739,8 @@
   const unsigned char *ctrl;
   const char *elem;
   struct stringbuf sb;
+/*LISSI*/
+  int gost_sign;
 
   /* FIXME: The entire function is very similar to keyinfo_to_sexp */
   *r_string = NULL;
@@ -1615,7 +1750,6 @@
   else
     algo_table = enc_algo_table;
 
-
   err = get_algorithm (1, der, derlen, &nread, &off, &len, &is_bitstr,
                        NULL, NULL, NULL);
   if (err)
@@ -1628,11 +1762,16 @@
            && !memcmp (der+off, algo_table[algoidx].oid, len))
         break;
     }
+
   if (!algo_table[algoidx].oid)
     return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
+
   if (!algo_table[algoidx].supported)
     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
 
+/*Определяем тип подписи по oid-у*/
+  gost_sign = !memcmp(algo_table[algoidx].oidstring, "1.2.643", 7);
+
   der += nread;
   derlen -= nread;
 
@@ -1682,8 +1821,22 @@
 
           put_stringbuf (&sb, "(");
           tmp[0] = *elem; tmp[1] = 0;
+/*Если ЭП по ГОСТ, то r находится справа, а s находится слева */
+	  if(gost_sign == 1 && algo_table == sig_algo_table){
+	    put_stringbuf_sexp (&sb, "r");
+	    put_stringbuf_mem_sexp (&sb, der+(len/2), len/2);
+    	    put_stringbuf (&sb, ")");
+    	    put_stringbuf (&sb, "(");
+	    put_stringbuf_sexp (&sb, "s");
+	    put_stringbuf_mem_sexp (&sb, der, len/2);
+	  }
+	  else{
+	  
           put_stringbuf_sexp (&sb, tmp);
           put_stringbuf_mem_sexp (&sb, der, len);
+/*Закрывающая скобка*/
+	  }
+
           der += len;
           derlen -= len;
           put_stringbuf (&sb, ")");

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>

#include <ctype.h>
#include <gcrypt.h>
#include <ksba.h>
/* Hash function used with libksba. */
#define HASH_FNC ((void (*)(void *, const void*,size_t))gcry_md_write)

/*Функция распечатки S-переменной*/
static void
show_sexp (const char *prefix, gcry_sexp_t a)
{
  char *buf;
  size_t size;

  if (prefix)
    fputs (prefix, stderr);
  size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
  buf = gcry_xmalloc (size);

  gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
  fprintf (stderr, "%.*s", (int)size, buf);
  gcry_free (buf);
}

/* Функция проверки подписи */
static gpg_error_t
check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
{
  gpg_error_t err;
  const char *algoid;
  gcry_md_hd_t md;
  int i, algo;
  ksba_sexp_t p;
  size_t n;
  /* Исходные данные для проверки подписи:
     S_PKEY    - S-переменная с открытым ключом.
     S_SIG     - S-переменная с подписью
     S_HASH    - S-переменная с вычисленным хэшом от tbs-сертификата
   */
  gcry_sexp_t s_sig, s_hash, s_pkey;
  const char *s;
  char algo_name[16+1]; /* hash algorithm name converted to lower case. */
  int digestlen;
  unsigned char *digest;
  int gost_key;

  /* Hash the target certificate using the algorithm from that certificate.  */
  algoid = ksba_cert_get_digest_algo (cert);
  algo = gcry_md_map_name (algoid);
  if (!algo)
    {
      fprintf(stderr, "unknown hash algorithm `%s'\n", algoid? algoid:"?");
      return (-1);	
    }
/*Определяем тип ключа*/
  gost_key = !memcmp(algoid, "1.2.643", 7);

  s = gcry_md_algo_name (algo);
  for (i=0; *s && i < sizeof algo_name - 1; s++, i++)
    algo_name[i] = tolower (*s);
  algo_name[i] = 0;   

  err = gcry_md_open (&md, algo, 0);
  if (err)
    {
      fprintf(stderr, "md_open failed: %s\n", algoid);
      return err;
    }

  err = ksba_cert_hash (cert, 1, HASH_FNC, md);
  if (err)
    {
      fprintf(stderr, "ksba_cert_hash failed: %s\n", algoid);
      gcry_md_close (md);
      return err;
    }
  gcry_md_final (md);

  /* Извлекаем значение подписи из сертификата*/
  p = ksba_cert_get_sig_val (cert);

  /* Извлекаем длину подписи*/
  n = gcry_sexp_canon_len (p, 0, NULL, NULL);
  if (!n)
    {
      gcry_md_close (md);
      ksba_free (p);
      return (-1);
    }
  /*Устанавливаем подпись в S-переменную библиотеки libgcrypt*/
  err = gcry_sexp_sscan ( &s_sig, NULL, p, n);
  ksba_free (p);
  if (err)
    {
      fprintf(stderr, "gcry_sexp_scan failed: %s\n", "Beda");
      gcry_md_close (md);
      return err;
    }
    /*Печать S-переменной подписи*/
  show_sexp ("Sig value:\n", s_sig);

  /* Читаем открытый ключ из сертификата */
  p = ksba_cert_get_public_key (issuer_cert);
  n = gcry_sexp_canon_len (p, 0, NULL, NULL);
  if (!n)
    {
      fprintf(stderr, "libksba did not return a proper S-Exp\n");
      gcry_md_close (md);
      ksba_free (p);
      gcry_sexp_release (s_sig);
      return (-1);
    }
  err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
  ksba_free (p);
  if (err)
    {
      fprintf(stderr, "gcry_sexp_scan failed: %s\n", "pubkey");
      gcry_md_close (md);
      gcry_sexp_release (s_sig);
      return err;
    }
    /*Печать S-переменной с открытым ключом*/
    show_sexp ("s_pkey:\n", s_pkey);
  digestlen = gcry_md_get_algo_dlen (algo);
  digest = gcry_md_read (md, algo);

    if (gost_key){
	unsigned char *h;
	unsigned char c;
	int len_xy;
/*Для тестирования архитектуры littlt-endian или big-endian*/
	unsigned short arch = 1; /* 0x0001 */
	h = digest;
	len_xy =  *((unsigned char *) &arch) == 0 ? 0:gcry_md_get_algo_dlen (algo);
/*Инвертируем хэш*/
	for (i = 0; i < (len_xy/2); i++) {
            	    c = *(h + i);
            	    *(h + i) = *(h + len_xy - i - 1);
            	    *(h + len_xy - i - 1) = c;
	}
    }

     switch (gost_key) {
	    case 0: 
		if ( gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
                       algo_name, (int)digestlen, digest) ) {
		    exit (1);
		}
		break;
	    case 1: 
		if ( gcry_sexp_build (&s_hash, NULL, "(data(flags gost)(value %b))",
                        (int)digestlen, digest) ) {
		    exit (1);
		}
		break;
	    default:
		    exit (1);
    }

    /*Печать S-переменной с хэшом tbs-сертификата*/
    show_sexp ("s_hash:\n", s_hash);
    /*Проверка подписи*/
  err = gcry_pk_verify (s_sig, s_hash, s_pkey);
/*Освобождаем память*/
  gcry_md_close (md);
  gcry_sexp_release (s_sig);
  gcry_sexp_release (s_hash);
  gcry_sexp_release (s_pkey);
  return err;
}

int main (int argc, unsigned char *argv[]) {
  FILE *fp;
  ksba_reader_t r;
  ksba_cert_t cert;
  FILE *fp_ca;
  ksba_reader_t r_ca;
  ksba_cert_t cert_ca;
  gpg_error_t err;
  unsigned char *sub_dn;

    if(argc != 3) {
	fprintf(stderr, "Usage: check_cert <Проверяемый сертификат> <Корневой сертификат>\n");
	exit(1);
    }
  fp = fopen (argv[1], "rb");
  if (!fp)
    {
      fprintf (stderr, "check_cert: can't open `%s'\n", argv[1]);
      exit (1);
    }

  err = ksba_reader_new (&r);
  if (err) {
	fprintf(stderr, "ksba_reader_new error\n");
	exit(1);
  }
  err = ksba_reader_set_file (r, fp);
  if (err) {
	fprintf(stderr, "ksba_reader_set error\n");
	exit(1);
  }

  err = ksba_cert_new (&cert);
  if (err){
	fprintf(stderr, "ksba_cert_new error\n");
	exit(1);
  }

  err = ksba_cert_read_der (cert, r);
  if (err){
	fprintf(stderr, "ksba_cert_read_der error\n");
	exit(1);
  }
  fp_ca = fopen (argv[2], "rb");
  if (!fp_ca)
    {
      fprintf (stderr, "check_cert: can't open `%s'\n", argv[2]);
      exit (1);
    }

  err = ksba_reader_new (&r_ca);
  if (err) {
	fprintf(stderr, "ksba_reader_new error\n");
	exit(1);
  }
  err = ksba_reader_set_file (r_ca, fp_ca);
  if (err) {
	fprintf(stderr, "ksba_reader_set error\n");
	exit(1);
  }

  err = ksba_cert_new (&cert_ca);
  if (err){
	fprintf(stderr, "ksba_cert_new error\n");
	exit(1);
  }

  err = ksba_cert_read_der (cert_ca, r_ca);
  if (err){
	fprintf(stderr, "ksba_cert_read_der error\n");
	exit(1);
  }

    sub_dn = ksba_cert_get_subject (cert, 0);
    fprintf(stderr, "check_cert: Verify %s\n", sub_dn);
    
    err = check_cert_sig (cert_ca, cert);
  if (err) {
    fprintf(stderr, "check_cert: verify %s error\n", argv[1]);
  } else {
    fprintf(stderr, "check_cert: verify %s Ok\n", argv[1]);
  }

}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <errno.h>

#include <ksba.h>

//#include "t-common.h"
#include <gcrypt.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
/* Hash function used with libksba. */
#define HASH_FNC ((void (*)(void *, const void*,size_t))gcry_md_write)
void
dump_isotime (const ksba_isotime_t t)
{
  if (!t || !*t)
    fprintf (stderr, "[none]");
  else
    fprintf (stderr,"%.4s-%.2s-%.2s %.2s:%.2s:%s",
                t, t+4, t+6, t+9, t+11, t+13);
}

static void
show_sexp (const char *prefix, gcry_sexp_t a)
{
  char *buf;
  size_t size;

  if (prefix)
    fputs (prefix, stderr);
  size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
  buf = gcry_xmalloc (size);

  gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
  fprintf (stderr, "%.*s", (int)size, buf);
  gcry_free (buf);
}

void
dummy_hash_fnc (void *arg, const void *buffer, size_t length)
{
  (void)arg;
  (void)buffer;
  (void)length;
}

static int
dummy_writer_cb (void *cb_value, const void *buffer, size_t count)
{
  (void)cb_value;
  (void)buffer;
  (void)count;
  return 0;
}
/*Считаем хэш от файла*/
unsigned char *dgst_file (char *oid, char* fcont, int *len_h)
{
  gcry_md_hd_t hd;
  gcry_error_t err;
  int algo;
      FILE *fp;
      unsigned char buf[1024];
      size_t size;
      int i;
    unsigned char *h;
    unsigned char *ret_h;

  algo = gcry_md_map_name (oid);
  if (algo == GCRY_MD_NONE)
	return NULL;
	
  err = gcry_md_open(&hd, algo, 0);
  if (err)
	return NULL;

      fp = fopen (fcont, "r");

      if (fp == NULL) 
      	    return NULL;

      while (!feof (fp))
        {
          size = fread (buf, 1, sizeof(buf), fp);
          gcry_md_write (hd, buf, size);
        }

      h  = gcry_md_read(hd, 0);

      *len_h = gcry_md_get_algo_dlen (algo);
    ret_h = malloc(*len_h);
    memcpy(ret_h, h, *len_h);
      gcry_md_reset(hd);

  gcry_md_close(hd);
  return ret_h;
}

gcry_error_t one_file (const char *fname, char *fcontent, char *fcert)
{
  gcry_error_t err;
  FILE *fp;
  ksba_reader_t r;
  ksba_writer_t w;
  ksba_cms_t cms;
  int i;
  const char *algoid;
  ksba_stop_reason_t stopreason;
  const char *s = NULL;
  size_t n;
  ksba_sexp_t p;
  char *dn;
  int idx;
  ksba_cert_t cert;
  int ii;
  unsigned char *cert_der;
  int cert_der_len;
  int f_der;
  int rez;
  ksba_sexp_t p1;
  size_t n1;
  gcry_sexp_t s_sig, s_hash, s_pkey, s_num;
  int gost_key;
  gcry_md_hd_t md;
  int rc;
  int digestlen;
  unsigned char *digest;
  gcry_md_hd_t data_md = NULL;
  ksba_isotime_t sigtime;
  unsigned char *sub_dn; //dn - подписанта
  char *is_dn; //dn - выдавшего сертификат
  ksba_sexp_t sub_p; //номер сертификата
  
  fprintf (stderr, "\n*** checking `%s' ***\n", fname);
  fp = fopen (fname, "r");
  if (!fp) {
      fprintf (stderr, "can't open `%s'\n", fname);
      exit (1);
  }

  err = ksba_reader_new (&r);
  if (err) {
      fprintf (stderr, "can't  reader `%s'\n", fname);
      exit (1);
  }
  err = ksba_reader_set_file (r, fp);
  if (err) {
      fprintf (stderr, "can't  reader set `%s'\n", fname);
      exit (1);
  }
  /* Also create a writer so that cms.c won't return an error when
     writing processed content.  */
  err = ksba_writer_new (&w);
  if (err) {
      exit (1);
  }
  err = ksba_writer_set_cb (w, dummy_writer_cb, NULL);
  if (err) {
      exit (1);
  }
 
  switch (ksba_cms_identify (r))
    {
    case KSBA_CT_SIGNED_DATA:    s = "signed data"; break;
    case KSBA_CT_DATA:           s = "data";
    case KSBA_CT_ENVELOPED_DATA: if (s == NULL) s  = "enveloped data";
    case KSBA_CT_DIGESTED_DATA:  if (s == NULL) s = "digested data";
    case KSBA_CT_ENCRYPTED_DATA: if (s == NULL) s = "encrypted data";
    case KSBA_CT_AUTH_DATA:      if (s == NULL) s = "auth data"; 
    default:                     if (s == NULL) s = "unknown"; 
	printf ("identified as: %s\n", s);
	exit(1);
    }

  err = ksba_cms_new (&cms);
  if (err) {
    exit(1);
  }

  err = ksba_cms_set_reader_writer (cms, r, w);
  if (err) {
    exit(1);
  }

  rc = gcry_md_open (&data_md, 0, 0);
  if (rc)
    {
      fprintf (stderr, "md_open failed: \n");
      exit(1);;
    }

  err = ksba_cms_parse (cms, &stopreason);
  if (err) {
      fprintf (stderr, "ksba_cms_parse: cannot parse %s\n", fname);
    exit(1);
  }

  ksba_cms_set_hash_function (cms, dummy_hash_fnc, NULL);

  do
    {
      err = ksba_cms_parse (cms, &stopreason);
	if (err) {
    	    fprintf (stderr, "ksba_cms_parse: cannot parse %s\n", fname);
	    exit(1);
	}
    }
  while (stopreason != KSBA_SR_READY);

/*Читаем из PKCS7 сертификат подписанта*/
  cert_der_len = 0;
  for (ii=0; (cert=ksba_cms_get_cert (cms, ii)); ii++)
    {
      cert_der = (unsigned char*)ksba_cert_get_image(cert, (size_t *)&cert_der_len);
	f_der = open(fcert, O_RDWR|O_TRUNC|O_CREAT, 0666);
	if (f_der == -1) {
	    fprintf(stderr, "Bad open file=%s for cert\n", cert_der_len, fcert);
	    exit(1);
	}
/*Сохраняем в файле сертификат подписанта*/
        rez = write(f_der, cert_der, cert_der_len);
        close(f_der);
  /* Читаем публичный ключ из сертификата подписанта*/
  p1 = ksba_cert_get_public_key (cert);
  n1 = gcry_sexp_canon_len (p1, 0, NULL, NULL);
  if (!n1)
    {
      fprintf(stderr, "libksba did not return a proper S-Exp\n");
	exit(1);
    }
  err = gcry_sexp_sscan ( &s_pkey, NULL, p1, n1);
  ksba_free (p1);
  if (err)
    {
      fprintf(stderr, "gcry_sexp_scan failed: %s\n", "pubkey");
	exit(1);
    }

/*Читаем отличительное имя DN владельца сертификатп*/
    sub_dn = ksba_cert_get_subject (cert, 0);
 
      ksba_cert_release (cert);
    }
      for (idx=0; idx < 1; idx++) {
	  int algo;        
    	  int info_pkalgo;
	unsigned char *s;
	    int s_len;
	    int len_h;
	    unsigned char *dgst_h;
    	  
/*Читаем из подписи/PKCS#7 DN издателя сертификата подписанта is_dn и серийный номер сертификата подписанта sub_p*/
/*Именно по этим полям должен искать сертификат проверяющий*/
/*Мы исходим в примере из того, что сертификат подписанта лежит в контейнере PKCS#7*/
        err = ksba_cms_get_issuer_serial (cms, idx, &is_dn, &sub_p);
	if (err) { 
	    fprintf (stderr, "ksba_cms_get_issuer_serial cannot %s\n", fname);
	    exit(1);
	}
/*Читаем алгоритм хэша*/
        algoid = ksba_cms_get_digest_algo (cms, idx);

        err = ksba_cms_get_sigattr_oids (cms, 0, "1.2.840.113549.1.7.1",&dn);
	if (err && err != -1) { 
	    fprintf (stderr, "ksba_cms_get_sigattr_oids cannot %s err=%d\n", fname, err);
	    exit(1);
	}

	algo = gcry_md_map_name (algoid);
/*Имеем дело с ГОСТ-ами (1) или нет*/
	 gost_key = !memcmp(algoid, "1.2.643", 7);
                  gcry_md_enable (data_md, algo);

	  rc = gcry_md_open (&md, algo, 0);
	if (rc) {
        fprintf(stderr, "md_open failed:\n");
    	    exit(1);
	}
/*Устанавливаем хэш-функцию*/
	ksba_cms_set_hash_function (cms, HASH_FNC, data_md);
/*Получаем хэш от подписываемых атрибутов*/
	rc = ksba_cms_hash_signed_attrs (cms, idx);
	if (rc) {
    	    fprintf(stderr, "hashing signed attrs failed: \n");
    	    gcry_md_close (md);
	    continue;
	}
    gcry_md_final (md);
    digestlen = gcry_md_get_algo_dlen (algo);
/*Читаем значение хэша*/
    digest = gcry_md_read (data_md, algo);
    gcry_md_close (md);
    if (gost_key){
/*Имеем дело с ГОСТ*/
	unsigned char *h;
	unsigned char c;
	int len_xy;
/*Для тестирования архитектуры littlt-endian или big-endian*/
	unsigned short arch = 1; /* 0x0001 */
	h = digest;
	len_xy =  *((unsigned char *) &arch) == 0 ? 0:gcry_md_get_algo_dlen (algo);
/*Инвертируем хэш*/
	for (i = 0; i < (len_xy/2); i++) {
            	    c = *(h + i);
            	    *(h + i) = *(h + len_xy - i - 1);
            	    *(h + len_xy - i - 1) = c;
	}
    }
     switch (gost_key) {
	    case 0: 
		if ( gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
                       algoid, (int)digestlen, digest) ) {
		    fprintf(stderr, "BUG\n");      
		    exit (1);
		}
		break;
	    case 1: 
/*Это ГОСТ, создаем S-переменную со значением хэша*/
		if ( gcry_sexp_build (&s_hash, NULL, "(data(flags gost)(value %b))",
                        (int)digestlen, digest) ) {
		    exit (1);
		}
		break;
	    default:
		    exit (1);
    }

/*Читаем время создания подписи*/
      rc = ksba_cms_get_signing_time (cms, idx, sigtime);
      if (rc) {
          fprintf(stderr, "error getting signing time\n");
//          *sigtime = 0; /* (we can't encode an error in the time string.) */
          exit(1);
    }


/*Читаем значения хэша для подписанного документа из PKCS#7 */
          err = ksba_cms_get_message_digest (cms, idx, &dn, &n);
	if (err) { 
	    fprintf (stderr, "ksba_cms_get_message_digest cannot %s\n", fname);
	    exit(1);
	}
/*Считаем значение хэш от подписанного документа*/
    dgst_h = dgst_file ((char *)algoid, (char *)fcontent, &len_h);
    if (dgst_h == NULL) {
      fprintf(stderr, "\nBad digest  %s\n", fcontent);
      exit (1);
    } 
    if (memcmp(dgst_h, dn, n)) {
/*Что произошло: подменили документ, внесли изменения со времени подписания, изменили подпись и т.п.*/
      fprintf(stderr, "\nBad content  %s\n", fcontent);
      exit (1);
    } 

          ksba_free (dn);
          putchar ('\n');

          dn = ksba_cms_get_sig_val (cms, idx);
          if (!dn) {
            printf ("signer %d - signature not found\n", idx);
            exit(1);
          }
	n = gcry_sexp_canon_len ((ksba_sexp_t)dn, 0, NULL, NULL);
	if (!n){
	    fprintf(stderr, "libksba did not return a proper S-Exp\n");
    	    exit(1);
	}

	err = gcry_sexp_sscan ( &s_sig, NULL, dn, n);
	if (err){
    	    fprintf(stderr, "gcry_sexp_scan failed: %s\n", "Beda");
    	    exit(1);
	}

          ksba_free (dn);
    }


    fprintf(stderr, "\n===========================================================\n");
      if (*sigtime){
        fprintf (stderr, "Дата подписания документа:\n");
        dump_isotime (sigtime);
        fprintf (stderr, "\n");
      }
      else
        fprintf (stderr, "[date not given]\n");
    fprintf(stderr, "\nДокумент подписал: %s\n", sub_dn);
    fprintf(stderr, "\nСертификат выдал: %s\n", is_dn);
	n = gcry_sexp_canon_len ((ksba_sexp_t)sub_p, 0, NULL, NULL);
	if (!n){
	    fprintf(stderr, "libksba did not return a proper S-Exp NUM\n");
    	    exit(1);
	}

  err = gcry_sexp_sscan ( &s_num, NULL, sub_p, n);

    show_sexp ("\nНомер сертификата:\n", s_num);

    fprintf(stderr, "\n===========================================================\n");

/*Проверка подписи*/
    err = gcry_pk_verify (s_sig, s_hash, s_pkey);
//    if(err) {
	show_sexp ("s_pkey:\n", s_pkey);
	show_sexp ("s_sig:\n", s_sig);
	show_sexp ("s_hash:\n", s_hash);
//    }
  ksba_cms_release (cms);
  ksba_reader_release (r);
  fclose (fp);
  return (err);    

}

int
main (int argc, char **argv)
{
    gcry_error_t err;
    unsigned char *h;
    int *len_h;

    if(argc != 4) {
	fprintf(stderr, "Usage: check_cms <Проверяемая подпись> <Оригинал документа> <Куда сохранить сертификат подписанта>\n");
	exit(1);
    }
    err = one_file (argv[1], argv[2], argv[3]);
    if (err) {
	fprintf(stderr, "check_cms: verify %s error\n", argv[1]);
    } else {
	fprintf(stderr, "check_cms: verify %s Ok\n", argv[1]);
	fprintf(stderr, "check_cms: Сертификат подписанта сохранен в %s\n", argv[3]);

    }
    exit (0);
}