Return to rsaio.h CVS log

Up to [PGP] / pgp / src

Annotation of pgp/src/rsaio.h, revision 1.1.1.1

1.1       root        1: /*     C include file for RSA library I/O routines
                      2: 
                      3:        (c) Copyright 1986 by Philip Zimmermann.  All rights reserved.
                      4:        The author assumes no liability for damages resulting from the use 
                      5:        of this software, even if the damage results from defects in this 
                      6:        software.  No warranty is expressed or implied.  
                      7: 
                      8:        The external data representation for RSA messages and keys that
                      9:        some of these library routines assume is outlined in a paper by 
                     10:        Philip Zimmermann, "A Proposed Standard Format for RSA Cryptosystems",
                     11:        IEEE Computer, September 1986, Vol. 19 No. 9, pages 21-34.
                     12:        Some revisions to this data format have occurred since the paper
                     13:        was published.
                     14: 
                     15:        NOTE:  This assumes previous inclusion of "rsalib.h"
                     16: */
                     17: 
                     18: /* #define XHIGHFIRST */ /* determines external integer byteorder for I/O */
                     19: 
                     20: /*--------------------- Byte ordering stuff -------------------*/
                     21: #ifdef NEEDSWAP
                     22: #undef NEEDSWAP        /* make sure NEEDSWAP is initially undefined */
                     23: #endif
                     24: 
                     25: #ifdef HIGHFIRST       /* internal HIGHFIRST byte order */
                     26: #ifndef XHIGHFIRST     /* external LOWFIRST byte order */
                     27: #define NEEDSWAP /* internal byteorder differs from external byteorder */
                     28: #endif
                     29: #else  /* internal LOWFIRST byte order */
                     30: #ifdef XHIGHFIRST      /* external HIGHFIRST byte order */
                     31: #define NEEDSWAP /* internal byteorder differs from external byteorder */
                     32: #endif
                     33: #endif /* internal LOWFIRST byte order */
                     34: 
                     35: #ifdef NEEDSWAP
                     36: #define hilo_swap(r1,numbytes) hiloswap(r1,numbytes)
                     37: #define convert_order(r) hiloswap(r,units2bytes(global_precision))
                     38: #else
                     39: /* hilo_swap is nil because external representation is already the same */
                     40: #define hilo_swap(r1,numbytes) /* nil statement */
                     41: #define convert_order(r)       /* nil statement */
                     42: #endif /* not NEEDSWAP */
                     43: 
                     44: /*------------------ End byte ordering stuff -------------------*/
                     45: 
                     46: 
                     47: #ifndef RSAIO  /* not compiling RSAIO */
                     48:        /*      Bug in DSP2101 C compiler -- no function protypes 
                     49:                allowed when compiling those same functions. */
                     50: 
                     51: #ifdef EMBEDDED
                     52: int putchar(int c);            /* standard C library function from <stdio.h> */
                     53: #endif /* EMBEDDED */
                     54: 
                     55: int string_length(char *s);
                     56:        /* Returns string length */
                     57: 
                     58: int str2reg(unitptr reg,string digitstr);
                     59:        /* Converts a possibly-signed digit string into a large binary number.
                     60:           Returns assumed radix, derived from suffix 'h','o',b','.' */
                     61: 
                     62: void putstr(string s); /* Put out null-terminated ASCII string via putchar. */
                     63: void puthexbyte(byte b); /* Put out byte in ASCII hex via putchar. */
                     64: void puthexw16(word16 w); /* Put out 16-bit word in hex, high byte first. */
                     65: 
                     66: int display_in_base(string s,unitptr n,short radix);
                     67:        /* Display n in any base, such as base 10.  Returns number of digits. */
                     68: 
                     69: void mp_display(string s,unitptr r);
                     70:        /* Display register r in hex, with prefix string s. */
                     71: 
                     72: word16 checksum(register byteptr buf, register word16 count);
                     73:        /* Returns checksum of buffer. */
                     74: 
                     75: void fill0(byteptr buf,word16 bytecount);
                     76:        /* Zero-fill the byte buffer. */
                     77: 
                     78: void cbc_xor(register unitptr dst, register unitptr src, word16 bytecount);
                     79:        /* Performs the XOR necessary for RSA Cipher Block Chaining. */
                     80: 
                     81: void hiloswap(byteptr r1,short numbytes);
                     82:        /* Reverses the order of bytes in an array of bytes. */
                     83: 
                     84: short mpi2reg(register unitptr r, register byteptr buf);
                     85:        /* Converts to unit array from byte array with bit length prefix word. */
                     86: 
                     87: short reg2mpi(register byteptr buf, register unitptr r);
                     88:        /* Converts from unit array to byte array with bit length prefix word. */
                     89: 
                     90: short preblock(unitptr outreg, byteptr inbuf, short bytecount,
                     91:        unitptr modulus, boolean cksbit, byteptr randompad);
                     92:        /* Converts plaintext block into form suitable for RSA encryption. */
                     93: 
                     94: short postunblock(byteptr outbuf, unitptr inreg,
                     95:        unitptr modulus, boolean padded, boolean cksbit);
                     96:        /*      Converts a just-decrypted RSA block back 
                     97:                into unblocked plaintext form. */
                     98: 
                     99: #endif /* not compiling RSAIO */
                    100: 
                    101: /****************** end of RSA I/O library ************************/
                    102: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.