modarit.c

SecuDe是一个由安全应用程序接口组成,对验证机制、证件处理、PEM、X.400报文处理和密钥管理提供支持。SecuDe提供DES、 RSA杂凑函数、密钥生成以及数字签名的生成和核实等多种密码机制。

/*
 *  SecuDE Release 4.1 (GMD)
 */
/********************************************************************
 * Copyright (C) 1991, GMD. All rights reserved.                    *
 *                                                                  *
 *                                                                  *
 *                         NOTICE                                   *
 *                                                                  *
 *    Acquisition, use, and distribution of this module             *
 *    and related materials are subject to restrictions             *
 *    mentioned in each volume of the documentation.                *
 *                                                                  *
 ********************************************************************/

/*                                                             */
/*    PACKAGE   MODARIT                 VERSION 1.10b          */
/*                                         DATE 04.08.88       */
/*                                           BY Wolfgang Bott  */
/*                                          And Stephan Thiele */
/*                                                             */
/*    DESCRIPTION                                              */
/*      In MODARIT  sind die Modulo-Rechenroutinen             */
/*      zusammengefasst.                                       */
/*                                                             */
/*                                                             */
/*    EXPORT          DESCRIPTION                              */
/*      madd()          Modulo - Addition                      */
/*      msub()          Modulo - Subtraktion                   */
/*      mmult()         Modulo - Multiplikation                */
/*      mdiv()          Modulo - Division                      */
/*      mexp()          Modulo - Exponentiation                */
/*                                                             */
/*    USES            DESCRIPTION                              */
/*      add             Addition                               */
/*      comp            Vergleich                              */
/*      div             Division                               */
/*      mult            Multiplikation                         */
/*      sub             Subtraktion                            */
/*      trans           Uebertragen                            */
/*                                                             */
/*    INTERNAL        DESCRIPTION                              */
/*                                                             */
/*    BUGS                                                     */
/*      MODARIT ist fuer BS2000 nicht geeignet (wegen mexp     */
/*      werden dort die Assembler-Versionen verwendet)         */
/*                                                             */
/*-------------------------------------------------------------*/
 
/*-------------------------------------------------------------*/
/*   include-Dateien                                           */
/*-------------------------------------------------------------*/
 
#include "arithmetic.h"
 
/*-------------------------------------------------------------*/
/*   Preprocessor - Definitionen   (siehe token.h)             */
/*-------------------------------------------------------------*/
 
/*-------------------------------------------------------------*/
/*   Typ - Definitionen  ( siehe token.h )                     */
/*-------------------------------------------------------------*/
 
/*-------------------------------------------------------------*/
/*   externe Variablen - Deklarationen                         */
/*-------------------------------------------------------------*/
 
extern L_NUMBER  lz_null [];
extern L_NUMBER  lz_eins [];

/*-------------------------------------------------------+-----*/
/*                                                       | GMD */
/*   PROC madd                           VERSION 1.10b   +-----*/
/*                                          DATE 03.08.88      */
/*                                            BY Bott Wolfgang */
/*                                                             */
/*                                                             */
/*   DESCRIPTION: Moduloaddition.                              */
/*                Akzeptiert beliebige Zahlen als Eingabe,     */
/*                liefert aber garantiert einen Wert zwischen  */
/*                '0' und 'modulu - 1' zurueck.                */
/*                                                             */
/*   IN                 DESCRIPTION                            */
/*     op1                1. Summand                           */
/*     op2                2. Summand                           */
/*     modul              Modul bez. dem gerechnet wird.       */
/*                                                             */
/*   INOUT                                                     */
/*                                                             */
/*   OUT                                                       */
/*     erg                Summe von op1 und op2 mod. modul     */
/*                                                             */
/*-------------------------------------------------------------*/
 
madd(op1,op2,erg,modul)
 
  L_NUMBER op1[];
  L_NUMBER op2[];
  L_NUMBER erg[];
  L_NUMBER modul[];
 
{
   /*----------------------------------------------------------*/
   /*   Statements                                             */
   /*----------------------------------------------------------*/
 
   add(op1,op2,erg);
   if(comp(erg,modul) < 0)
        {
        return(0);
        }
   else
        {
        sub(erg,modul,erg);
        if (comp(erg,modul) < 0)
                {
                return(0);
                }
        else
                {
                div(erg,modul,erg,erg);
                }
        }  /* end else   */
 
	return(0);
}  /* end madd          */
 
/*-------------------------------------------------------------*/
/* E N D   O F   P R O C E D U R E  madd                       */
/*-------------------------------------------------------------*/

/*-------------------------------------------------------+-----*/
/*                                                       | GMD */
/*   PROC msub                           VERSION 1.10b   +-----*/
/*                                          DATE 03.08.88      */
/*                                            BY Bott Wolfgang */
/*                                                             */
/*                                                             */
/*   DESCRIPTION: Modulosubtraktion.                           */
/*                Akzeptiert beliebige Zahlen als Eingabe,     */
/*                liefert aber garantiert einen Wert zwischen  */
/*                '0' und 'modul - 1' zurueck.                 */
/*                                                             */
/*   IN                 DESCRIPTION                            */
/*     op1                Subtrahend als lange Zahl            */
/*     op2                Minuend als lange Zahl               */
/*     modul              Modul bez. dem gerechnet wird.       */
/*                                                             */
/*   INOUT                                                     */
/*                                                             */
/*   OUT                                                       */
/*     erg                Differenz aus Subtrahend und Minuend */
/*                                                             */
/*-------------------------------------------------------------*/
 
msub(op1,op2,erg,modul)
 
  L_NUMBER op1[];
  L_NUMBER op2[];
  L_NUMBER erg[];
  L_NUMBER modul[];
 
  {
 
   /*----------------------------------------------------------*/
   /*   Definitionen                                           */
   /*----------------------------------------------------------*/
 
    L_NUMBER temp[MAXLGTH];    /* Hilfsfeld um Zwischen-       */
                               /* ergebnis zu speichern        */

   /*----------------------------------------------------------*/
   /*   Statements                                             */
   /*----------------------------------------------------------*/
 
   if (comp(op1,op2) >= 0)
        {
        sub(op1,op2,erg);
        if (comp(erg,modul) >= 0) div(erg,modul,erg,erg);
        }
    else
        {
        add(op1,modul,temp);
        if (comp(temp,op2) >= 0)
                {
                sub(temp,op2,erg);
                if (comp(erg,modul) >= 0) div(erg,modul,erg,erg);
                }
           else
                {
                div(op2,modul,erg,erg);
                sub(temp,erg,erg);
                div(erg,modul,erg,erg);
                } /* end inner else                            */
        } /* end outer else                                    */

	return(0);
  }  /* end msub                                               */
 
/*-------------------------------------------------------------*/
/* E N D   O F   P R O C E D U R E  msub                       */
/*-------------------------------------------------------------*/

/*-------------------------------------------------------+-----*/
/*                                                       | GMD */
/*   PROC mmult                          VERSION 1.10b   +-----*/
/*                                          DATE 03.08.88      */
/*                                            BY Bott Wolfgang */
/*                                                             */
/*                                                             */
/*   DESCRIPTION: Modulomultiplikation.                        */
/*                Akzeptiert beliebige Zahlen als Eingabe,     */
/*                liefert aber garantiert einen Wert zwischen  */
/*                '0' und 'modul - 1' zurueck.                 */
/*                                                             */
/*   IN                 DESCRIPTION                            */
/*     op1                Die beiden faktoren als              */
/*     op2                lange Zahlen                         */
/*     modul              Der Modul bez. dem gerechnet wird    */
/*                                                             */
/*   INOUT                                                     */
/*                                                             */
/*   OUT                                                       */
/*     erg                Das Produkt mod. modul               */
/*                                                             */
/*-------------------------------------------------------------*/
 
mmult(op1,op2,erg,modul)
 
  L_NUMBER op1[];
  L_NUMBER op2[];
  L_NUMBER erg[];
  L_NUMBER modul[];
 
{
 
   /*----------------------------------------------------------*/
   /*   Definitionen                                           */
   /*----------------------------------------------------------*/
 
   static  L_NUMBER temp[2 * MAXLGTH];
                                       /*Hilfsfeld um Zwischen-*/
                                       /*ergebnis zu speichern */
 
   /*----------------------------------------------------------*/
   /*   Statements                                             */
   /*----------------------------------------------------------*/
 
   mult(op1,op2,temp);
   div(temp,modul,erg,erg);
 

	return(0);
}  /* end mmult                                                */
 
/*-------------------------------------------------------------*/
/* E N D   O F   P R O C E D U R E  mmult                      */
/*-------------------------------------------------------------*/

/*-------------------------------------------------------+-----*/
/*                                                       | GMD */
/*   PROC mdiv                           VERSION 1.10b   +-----*/
/*                                          DATE 03.08.88      */
/*                                            BY Bott Wolfgang */
/*                                                             */
/*                                                             */
/*   DESCRIPTION: Modulodivision.                              */
/*                Akzeptiert beliebige Zahlen als Eingabe,     */
/*                liefert aber garantiert einen Wert zwischen  */
/*                '0' und 'modul - 1' zurueck.                 */
/*                                                             */
/*   IN                 Description                            */
/*     op1                Divident als lange Zahl              */
/*     op2                Divisor als lange Zahl               */
/*     modul              Modul bez. dem gerechnet werden soll */
/*                                                             */
/*   INOUT                                                     */
/*                                                             */
/*   OUT                                                       */
/*     erg                Quotient mod. Modul                  */
/*                                                             */
/*   RET                                                       */
/*     -1                 Division durch 0                     */
/*                                                             */
/*-------------------------------------------------------------*/
 
mdiv(op1,op2,erg,modul)
 
  L_NUMBER op1[];
  L_NUMBER op2[];
  L_NUMBER erg[];
  L_NUMBER modul[];
{
   /*----------------------------------------------------------*/
   /*   Definitionen                                           */
   /*----------------------------------------------------------*/
   /*   Hilfsfelder                                            */
   /*----------------------------------------------------------*/
   static  L_NUMBER  x[MAXLGTH];
   static  L_NUMBER  y[MAXLGTH];
   static  L_NUMBER  r[MAXLGTH];