/*
 * Copyright (C) 2000-2021 Free Software Foundation, Inc.
 *
 * This file is part of LIBTASN1.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*****************************************************/
/* File: CrlExample.c                                */
/* Description: An example on how to use the ASN1    */
/*              parser with the Certificate.txt file */
/*****************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "libtasn1.h"


static char *
my_ltostr (long v, char *str)
{
  long d, r;
  char temp[20];
  int count, k, start;

  if (v < 0)
    {
      str[0] = '-';
      start = 1;
      v = -v;
    }
  else
    start = 0;

  count = 0;
  do
    {
      d = v / 10;
      r = v - d * 10;
      temp[start + count] = '0' + (char) r;
      count++;
      v = d;
    }
  while (v);

  for (k = 0; k < count; k++)
    str[k + start] = temp[start + count - k - 1];
  str[count + start] = 0;
  return str;
}


/******************************************************/
/* Function : get_name_type                           */
/* Description: analyze a structure of type Name      */
/* Parameters:                                        */
/*   char *root: the structure identifier             */
/*   char *answer: the string with elements like:     */
/*                 "C=US O=gov"                       */
/******************************************************/
static void
get_Name_type (asn1_node cert_def, asn1_node cert, const char *root,
	       unsigned char *ans)
{
  int k, k2, result, len;
  char name[128], str[1024], str2[1024], name2[128], counter[5], name3[128];
  asn1_node value = NULL;
  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
  char *answer = (char *) ans;

  answer[0] = 0;
  k = 1;
  do
    {
      strcpy (name, root);
      strcat (name, ".rdnSequence.?");
      my_ltostr (k, counter);
      strcat (name, counter);

      len = sizeof (str) - 1;
      result = asn1_read_value (cert, name, str, &len);
      if (result == ASN1_ELEMENT_NOT_FOUND)
	break;
      k2 = 1;
      do
	{
	  strcpy (name2, name);
	  strcat (name2, ".?");
	  my_ltostr (k2, counter);
	  strcat (name2, counter);

	  len = sizeof (str) - 1;
	  result = asn1_read_value (cert, name2, str, &len);
	  if (result == ASN1_ELEMENT_NOT_FOUND)
	    break;
	  strcpy (name3, name2);
	  strcat (name3, ".type");

	  len = sizeof (str) - 1;
	  result = asn1_read_value (cert, name3, str, &len);
	  strcpy (name3, name2);
	  strcat (name3, ".value");
	  if (result == ASN1_SUCCESS)
	    {
	      len = sizeof (str2);
	      result =
		asn1_read_value (cert_def,
				 "PKIX1Implicit88.id-at-countryName", str2,
				 &len);
	      if (!strcmp (str, str2))
		{
		  asn1_create_element (cert_def,
				       "PKIX1Implicit88.X520OrganizationName",
				       &value);
		  len = sizeof (str) - 1;
		  asn1_read_value (cert, name3, str, &len);
		  result =
		    asn1_der_decoding (&value, str, len, errorDescription);

		  len = sizeof (str) - 1;
		  asn1_read_value (value, "", str, &len);	/* CHOICE */

		  strcpy (name3, str);

		  len = sizeof (str) - 1;
		  asn1_read_value (value, name3, str, &len);
		  str[len] = 0;
		  strcat (answer, " C=");
		  strcat (answer, str);

		  asn1_delete_structure (&value);
		}
	      else
		{
		  len = sizeof (str2);
		  result =
		    asn1_read_value (cert_def,
				     "PKIX1Implicit88.id-at-organizationName",
				     str2, &len);
		  if (!strcmp (str, str2))
		    {
		      asn1_create_element (cert_def,
					   "PKIX1Implicit88.X520OrganizationName",
					   &value);

		      len = sizeof (str) - 1;
		      asn1_read_value (cert, name3, str, &len);
		      asn1_der_decoding (&value, str, len, errorDescription);
		      len = sizeof (str) - 1;
		      asn1_read_value (value, "", str, &len);	/* CHOICE */
		      strcpy (name3, str);
		      len = sizeof (str) - 1;
		      asn1_read_value (value, name3, str, &len);
		      str[len] = 0;
		      strcat (answer, " O=");
		      strcat (answer, str);
		      asn1_delete_structure (&value);
		    }
		  else
		    {
		      len = sizeof (str2);
		      result =
			asn1_read_value (cert_def,
					 "PKIX1Implicit88.id-at-organizationalUnitName",
					 str2, &len);
		      if (!strcmp (str, str2))
			{
			  asn1_create_element (cert_def,
					       "PKIX1Implicit88.X520OrganizationalUnitName",
					       &value);
			  len = sizeof (str) - 1;
			  asn1_read_value (cert, name3, str, &len);
			  asn1_der_decoding (&value, str, len,
					     errorDescription);
			  len = sizeof (str) - 1;
			  asn1_read_value (value, "", str, &len);	/* CHOICE */
			  strcpy (name3, str);
			  len = sizeof (str) - 1;
			  asn1_read_value (value, name3, str, &len);
			  str[len] = 0;
			  strcat (answer, " OU=");
			  strcat (answer, str);
			  asn1_delete_structure (&value);
			}
		    }
		}
	    }
	  k2++;
	}
      while (1);
      k++;
    }
  while (1);
}


/******************************************************/
/* Function : create_certificate                      */
/* Description: creates a certificate named           */
/*              "certificate1". Values are the same   */
/*              as in rfc2459 Appendix D.1            */
/* Parameters:                                        */
/*   unsigned char *der: contains the der encoding    */
/*   int *der_len: number of bytes of der string      */
/******************************************************/
static void
create_CRL (asn1_node cert_def, unsigned char *der, int *der_len)
{
  int result, k, len;
  unsigned char str[1024];
  const unsigned char *str2;
  asn1_node crl = NULL;
  asn1_node value = NULL;
  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
  int max_len;

  max_len = *der_len;

  result =
    asn1_create_element (cert_def, "PKIX1Implicit88.CertificateList", &crl);

  /* Use the next 3 lines to visit the empty certificate */
  /*  printf("-----------------\n");
     asn1_visit_tree(crl,"");
     printf("-----------------\n"); */


  /* version: v2(1) */
  result = asn1_write_value (crl, "tbsCertList.version", "v2", 0);


  /* signature: dsa-with-sha */
  len = sizeof (str) - 1;
  result =
    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
  result = asn1_write_value (crl, "tbsCertList.signature.algorithm", str, 1);
  result =
    asn1_write_value (crl, "tbsCertList.signature.parameters", NULL, 0);


  /* issuer: Country="US" Organization="gov" OrganizationUnit="nist" */
  result = asn1_write_value (crl, "tbsCertList.issuer", "rdnSequence", 1);

  result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 1);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 1);
  /* C */
  len = sizeof (str) - 1;
  result =
    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-countryName", str,
		     &len);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
		      str, 1);
  result =
    asn1_create_element (cert_def, "PKIX1Implicit88.X520countryName", &value);
  result = asn1_write_value (value, "", "US", 2);
  *der_len = max_len;
  result = asn1_der_coding (value, "", der, der_len, errorDescription);

  asn1_delete_structure (&value);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
		      der, *der_len);


  result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 4);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 4);
  /* O */
  len = sizeof (str) - 1;
  result =
    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationName", str,
		     &len);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
		      str, 8);
  result =
    asn1_create_element (cert_def, "PKIX1Implicit88.X520OrganizationName",
			 &value);
  result = asn1_write_value (value, "", "printableString", 1);
  result = asn1_write_value (value, "printableString", "gov", 3);
  *der_len = max_len;
  result = asn1_der_coding (value, "", der, der_len, errorDescription);
  asn1_delete_structure (&value);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
		      der, *der_len);


  result = asn1_write_value (crl, "tbsCertList.issuer.rdnSequence", "NEW", 1);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST", "NEW", 1);
  /* OU */
  len = sizeof (str) - 1;
  result =
    asn1_read_value (cert_def, "PKIX1Implicit88.id-at-organizationalUnitName",
		     str, &len);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.type",
		      str, 1);
  result =
    asn1_create_element (cert_def,
			 "PKIX1Implicit88.X520OrganizationalUnitName",
			 &value);
  result = asn1_write_value (value, "", "printableString", 1);
  result = asn1_write_value (value, "printableString", "nist", 4);
  *der_len = max_len;
  result = asn1_der_coding (value, "", der, der_len, errorDescription);
  asn1_delete_structure (&value);
  result =
    asn1_write_value (crl, "tbsCertList.issuer.rdnSequence.?LAST.?LAST.value",
		      der, *der_len);


  /* validity */
  result = asn1_write_value (crl, "tbsCertList.thisUpdate", "utcTime", 1);
  result =
    asn1_write_value (crl, "tbsCertList.thisUpdate.utcTime", "970801000000Z",
		      1);

  result = asn1_write_value (crl, "tbsCertList.nextUpdate", "utcTime", 1);
  result =
    asn1_write_value (crl, "tbsCertList.nextUpdate.utcTime", "970808000000Z",
		      1);


  /* revokedCertificates */
  result =
    asn1_write_value (crl, "tbsCertList.revokedCertificates", "NEW", 1);
  str[0] = 18;
  result =
    asn1_write_value (crl,
		      "tbsCertList.revokedCertificates.?LAST.userCertificate",
		      str, 1);
  result =
    asn1_write_value (crl,
		      "tbsCertList.revokedCertificates.?LAST.revocationDate",
		      "utcTime", 1);
  result =
    asn1_write_value (crl,
		      "tbsCertList.revokedCertificates.?LAST.revocationDate.utcTime",
		      "970731000000Z", 1);

  result =
    asn1_write_value (crl,
		      "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions",
		      "NEW", 1);
  len = sizeof (str) - 1;
  result = asn1_read_value (cert_def, "PKIX1Implicit88.id-ce-cRLReasons",
			    str, &len);
  result = asn1_write_value (crl, "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnID", str, 1);	/* reasonCode */
  result =
    asn1_write_value (crl,
		      "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.critical",
		      "FALSE", 1);
  str2 = (const unsigned char *) "\x0a\x01\x01";
  result =
    asn1_write_value (crl,
		      "tbsCertList.revokedCertificates.?LAST.crlEntryExtensions.?LAST.extnValue",
		      str2, 3);


  /* crlExtensions */
  result = asn1_write_value (crl, "tbsCertList.crlExtensions", NULL, 0);


  /* signatureAlgorithm: dsa-with-sha  */
  len = sizeof (str) - 1;
  result =
    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str, &len);
  result = asn1_write_value (crl, "signatureAlgorithm.algorithm", str, 1);
  result = asn1_write_value (crl, "signatureAlgorithm.parameters", NULL, 0);	/* NO OPTION */

  /* signature */
  *der_len = max_len;
  result =
    asn1_der_coding (crl, "tbsCertList", der, der_len, errorDescription);
  if (result != ASN1_SUCCESS)
    {
      printf ("\n'tbsCertList' encoding creation: ERROR\n");
      return;
    }

  /* add the lines for the signature on der[0]..der[der_len-1]: result in str2 */
  result = asn1_write_value (crl, "signature", str2, 46 * 8);


  /* Use the next 3 lines to visit the certificate */
  /* printf("-----------------\n");
     asn1_visit_tree(crl,"");
     printf("-----------------\n"); */

  *der_len = max_len;
  result = asn1_der_coding (crl, "", der, der_len, errorDescription);
  if (result != ASN1_SUCCESS)
    {
      printf ("\n'crl1' encoding creation: ERROR\n");
      return;
    }

  /* Print the 'Certificate1' DER encoding */
  printf ("-----------------\nCrl1 Encoding:\nNumber of bytes=%i\n",
	  *der_len);
  for (k = 0; k < *der_len; k++)
    printf ("%02x ", der[k]);
  printf ("\n-----------------\n");

  /* Clear the "certificate1" structure */
  asn1_delete_structure (&crl);
}


/******************************************************/
/* Function : get_certificate                         */
/* Description: creates a certificate named           */
/*              "certificate2" from a der encoding    */
/*              string                                */
/* Parameters:                                        */
/*   unsigned char *der: the encoding string          */
/*   int der_len: number of bytes of der string      */
/******************************************************/
static void
get_CRL (asn1_node cert_def, unsigned char *der, int der_len)
{
  int result, len, start, end;
  unsigned char str[1024], str2[1024];
  asn1_node crl2 = NULL;
  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];


  asn1_create_element (cert_def, "PKIX1Implicit88.CertificateList", &crl2);

  result = asn1_der_decoding (&crl2, der, der_len, errorDescription);

  if (result != ASN1_SUCCESS)
    {
      printf ("Problems with DER encoding\n");
      return;
    }


  /* issuer */
  get_Name_type (cert_def, crl2, "tbsCertList.issuer", str);
  printf ("crl2:\nissuer: %s\n", str);


  /* Verify sign */
  len = sizeof (str) - 1;
  result = asn1_read_value (crl2, "signatureAlgorithm.algorithm", str, &len);

  result =
    asn1_read_value (cert_def, "PKIX1Implicit88.id-dsa-with-sha1", str2,
		     &len);
  if (!strcmp ((char *) str, (char *) str2))
    {				/* dsa-with-sha */

      result = asn1_der_decoding_startEnd (crl2, der, der_len,
					   "tbsCertList", &start, &end);

      /* add the lines to calculate the sha on der[start]..der[end] */

      result = asn1_read_value (crl2, "signature", str, &len);

      /* compare the previous value to signature ( with issuer public key) */
    }

  /* Use the next 3 lines to visit the certificate */
  /* printf("-----------------\n");
     asn1_visit_tree(crl2,"");
     printf("-----------------\n"); */


  /* Clear the "crl2" structure */
  asn1_delete_structure (&crl2);
}

extern const asn1_static_node pkix_asn1_tab[];

/********************************************************/
/* Function : main                                      */
/* Description: reads the certificate description.      */
/*              Creates a certificate and calculate     */
/*              the der encoding. After that creates    */
/*              another certificate from der string     */
/********************************************************/
int
main (int argc, char *argv[])
{
  int result, der_len;
  unsigned char der[1024];
  asn1_node PKIX1Implicit88 = NULL;
  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];

  if (1)
    result =
      asn1_array2tree (pkix_asn1_tab, &PKIX1Implicit88, errorDescription);
  else
    result =
      asn1_parser2tree ("pkix.asn", &PKIX1Implicit88, errorDescription);

  if (result != ASN1_SUCCESS)
    {
      asn1_perror (result);
      printf ("%s\n", errorDescription);
      exit (1);
    }

  /* Use the following 3 lines to visit the PKIX1Implicit structures */
  /* printf("-----------------\n");
     asn1_visit_tree(cert_def,"PKIX1Implicit88");
     printf("-----------------\n"); */

  der_len = 1024;
  create_CRL (PKIX1Implicit88, der, &der_len);


  get_CRL (PKIX1Implicit88, der, der_len);

  /* Clear the "PKIX1Implicit88" structures */
  asn1_delete_structure (&PKIX1Implicit88);

  return 0;
}