wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove obsolete files from SSLeay 0.8.

Browse source
This commit is contained in:
Ulf Möller 1999-04-06 15:22:55 +00:00
parent 121bd68d1c
commit e8d628156f
30 changed files with 0 additions and 5366 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

324
apps/bss_file.c
View file

@ -1,324 +0,0 @@
/* crypto/bio/bss_file.c */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#define APPS_WIN16
#include <stdio.h>
#include <errno.h>
#include "cryptlib.h"
#include "bio.h"
#include "err.h"
#ifndef NOPROTO
static int MS_CALLBACK file_write(BIO *h,char *buf,int num);
static int MS_CALLBACK file_read(BIO *h,char *buf,int size);
static int MS_CALLBACK file_puts(BIO *h,char *str);
static int MS_CALLBACK file_gets(BIO *h,char *str,int size);
static long MS_CALLBACK file_ctrl(BIO *h,int cmd,long arg1,char *arg2);
static int MS_CALLBACK file_new(BIO *h);
static int MS_CALLBACK file_free(BIO *data);
#else
static int MS_CALLBACK file_write();
static int MS_CALLBACK file_read();
static int MS_CALLBACK file_puts();
static int MS_CALLBACK file_gets();
static long MS_CALLBACK file_ctrl();
static int MS_CALLBACK file_new();
static int MS_CALLBACK file_free();
#endif
static BIO_METHOD methods_filep=
{
BIO_TYPE_FILE,"FILE pointer",
file_write,
file_read,
file_puts,
file_gets,
file_ctrl,
file_new,
file_free,
};
BIO *BIO_new_file(filename,mode)
char *filename;
char *mode;
{
BIO *ret;
FILE *file;
if ((file=fopen(filename,mode)) == NULL)
{
SYSerr(SYS_F_FOPEN,errno);
BIOerr(BIO_F_BIO_NEW_FILE,ERR_R_SYS_LIB);
return(NULL);
}
if ((ret=BIO_new_fp(file,BIO_CLOSE)) == NULL)
{
fclose(file);
return(NULL);
}
return(ret);
}
BIO *BIO_new_fp(stream,close_flag)
FILE *stream;
int close_flag;
{
BIO *ret;
if ((ret=BIO_new(BIO_s_file())) == NULL)
return(NULL);
BIO_set_fp(ret,stream,close_flag);
return(ret);
}
#if !defined(WIN16) || defined(APPS_WIN16)
BIO_METHOD *BIO_s_file()
{
return(&methods_filep);
}
#else
BIO_METHOD *BIO_s_file_internal_w16()
{
return(&methods_filep);
}
#endif
static int MS_CALLBACK file_new(bi)
BIO *bi;
{
bi->init=0;
bi->num=0;
bi->ptr=NULL;
return(1);
}
static int MS_CALLBACK file_free(a)
BIO *a;
{
if (a == NULL) return(0);
if (a->shutdown)
{
if ((a->init) && (a->ptr != NULL))
{
fclose((FILE *)a->ptr);
a->ptr=NULL;
}
a->init=0;
}
return(1);
}
static int MS_CALLBACK file_read(b,out,outl)
BIO *b;
char *out;
int outl;
{
int ret=0;
if (b->init && (out != NULL))
{
ret=fread(out,1,(int)outl,(FILE *)b->ptr);
}
return(ret);
}
static int MS_CALLBACK file_write(b,in,inl)
BIO *b;
char *in;
int inl;
{
int ret=0;
if (b->init && (in != NULL))
{
if (fwrite(in,(int)inl,1,(FILE *)b->ptr))
ret=inl;
/* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */
/* acording to Tim Hudson <tjh@cryptsoft.com>, the commented
* out version above can cause 'inl' write calls under
* some stupid stdio implementations (VMS) */
}
return(ret);
}
static long MS_CALLBACK file_ctrl(b,cmd,num,ptr)
BIO *b;
int cmd;
long num;
char *ptr;
{
long ret=1;
FILE *fp=(FILE *)b->ptr;
FILE **fpp;
char p[4];
switch (cmd)
{
case BIO_CTRL_RESET:
ret=(long)fseek(fp,num,0);
break;
case BIO_CTRL_EOF:
ret=(long)feof(fp);
break;
case BIO_CTRL_INFO:
ret=ftell(fp);
break;
case BIO_C_SET_FILE_PTR:
file_free(b);
b->shutdown=(int)num;
b->ptr=(char *)ptr;
b->init=1;
break;
case BIO_C_SET_FILENAME:
file_free(b);
b->shutdown=(int)num&BIO_CLOSE;
if (num & BIO_FP_APPEND)
{
if (num & BIO_FP_READ)
strcpy(p,"a+");
else strcpy(p,"a");
}
else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))
strcpy(p,"r+");
else if (num & BIO_FP_WRITE)
strcpy(p,"w");
else if (num & BIO_FP_READ)
strcpy(p,"r");
else
{
BIOerr(BIO_F_FILE_CTRL,BIO_R_BAD_FOPEN_MODE);
ret=0;
break;
}
#if defined(MSDOS) || defined(WINDOWS)
if (!(num & BIO_FP_TEXT))
strcat(p,"b");
else
strcat(p,"t");
#endif
fp=fopen(ptr,p);
if (fp == NULL)
{
SYSerr(SYS_F_FOPEN,errno);
BIOerr(BIO_F_FILE_CTRL,ERR_R_SYS_LIB);
ret=0;
break;
}
b->ptr=(char *)fp;
b->init=1;
break;
case BIO_C_GET_FILE_PTR:
/* the ptr parameter is actually a FILE ** in this case. */
if (ptr != NULL)
{
fpp=(FILE **)ptr;
*fpp=(FILE *)b->ptr;
}
break;
case BIO_CTRL_GET_CLOSE:
ret=(long)b->shutdown;
break;
case BIO_CTRL_SET_CLOSE:
b->shutdown=(int)num;
break;
case BIO_CTRL_FLUSH:
fflush((FILE *)b->ptr);
break;
case BIO_CTRL_DUP:
ret=1;
break;
case BIO_CTRL_PENDING:
case BIO_CTRL_PUSH:
case BIO_CTRL_POP:
default:
ret=0;
break;
}
return(ret);
}
static int MS_CALLBACK file_gets(bp,buf,size)
BIO *bp;
char *buf;
int size;
{
int ret=0;
buf[0]='\0';
fgets(buf,size,(FILE *)bp->ptr);
if (buf[0] != '\0')
ret=strlen(buf);
return(ret);
}
static int MS_CALLBACK file_puts(bp,str)
BIO *bp;
char *str;
{
int n,ret;
n=strlen(str);
ret=file_write(bp,str,n);
return(ret);
}

9
apps/c512-key.pem
View file

@ -1,9 +0,0 @@
-----BEGIN RSA PRIVATE KEY-----
MIIBOwIBAAJBALtv55QyzG6i2PlwZ1pah7++Gv8L5j6Hnyr/uTZE1NLG0ABDDexm
q/R4KedLjFEIYjocDui+IXs62NNtXrT8odkCAwEAAQJAbwXq0vJ/+uyEvsNgxLko
/V86mGXQ/KrSkeKlL0r4ENxjcyeMAGoKu6J9yMY7+X9+Zm4nxShNfTsf/+Freoe1
HQIhAPOSm5Q1YI+KIsII2GeVJx1U69+wnd71OasIPakS1L1XAiEAxQAW+J3/JWE0
ftEYakbhUOKL8tD1OaFZS71/5GdG7E8CIQCefUMmySSvwd6kC0VlATSWbW+d+jp/
nWmM1KvqnAo5uQIhALqEADu5U1Wvt8UN8UDGBRPQulHWNycuNV45d3nnskWPAiAw
ueTyr6WsZ5+SD8g/Hy3xuvF3nPmJRH+rwvVihlcFOg==
-----END RSA PRIVATE KEY-----

8
apps/c512-req.pem
View file

@ -1,8 +0,0 @@
-----BEGIN CERTIFICATE REQUEST-----
MIIBGzCBxgIBADBjMQswCQYDVQQGEwJBVTETMBEGA1UECBMKUXVlZW5zbGFuZDEa
MBgGA1UEChMRQ3J5cHRTb2Z0IFB0eSBMdGQxIzAhBgNVBAMTGkNsaWVudCB0ZXN0
IGNlcnQgKDUxMiBiaXQpMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALtv55QyzG6i
2PlwZ1pah7++Gv8L5j6Hnyr/uTZE1NLG0ABDDexmq/R4KedLjFEIYjocDui+IXs6
2NNtXrT8odkCAwEAATANBgkqhkiG9w0BAQQFAANBAC5JBTeji7RosqMaUIDzIW13
oO6+kPhx9fXSpMFHIsY3aH92Milkov/2A4SuZTcnv/P6+8klmS0EaiUKcRzak4E=
-----END CERTIFICATE REQUEST-----

8
apps/crl.out
View file

@ -1,8 +0,0 @@
-----BEGIN X509 CRL-----
MIIBDjCBuTANBgkqhkiG9w0BAQQFADBgMQswCQYDVQQGEwJBVTEMMAoGA1UECBMD
UUxEMRkwFwYDVQQKExBNaW5jb20gUHR5LiBMdGQuMQswCQYDVQQLEwJDUzEbMBkG
A1UEAxMSU1NMZWF5IGRlbW8gc2VydmVyFw05NzA3MDkwMDAwMjJaFw05NzA4MDgw
MDAwMjJaMCgwEgIBARcNOTUxMDA5MjMzMjA1WjASAgEDFw05NTEyMDEwMTAwMDBa
MA0GCSqGSIb3DQEBBAUAA0EAcEBIWVZPXxSlLMPPLfBi4s0N3lzTgskZkgO6pjZi
oQRwh5vi5zFqDNQteGx7RTHpUYntgyoAZ87FZE0GOJgBaQ==
-----END X509 CRL-----

25
apps/stuff/pkcs7.ex1
View file

@ -1,25 +0,0 @@
-----BEGIN xxx-----
MIAGCSqGSIb3DQEHAqCAMIACAQExADCABgkqhkiG9w0BBwEAAKCAMIIB
rTCCAUkCAgC2MA0GCSqGSIb3DQEBAgUAME0xCzAJBgNVBAYTAlVTMSAw
HgYDVQQKExdSU0EgRGF0YSBTZWN1cml0eSwgSW5jLjEcMBoGA1UECxMT
UGVyc29uYSBDZXJ0aWZpY2F0ZTAeFw05NDA0MDkwMDUwMzdaFw05NDA4
MDIxODM4NTdaMGcxCzAJBgNVBAYTAlVTMSAwHgYDVQQKExdSU0EgRGF0
YSBTZWN1cml0eSwgSW5jLjEcMBoGA1UECxMTUGVyc29uYSBDZXJ0aWZp
Y2F0ZTEYMBYGA1UEAxMPU2V0ZWMgQXN0cm9ub215MFwwDQYJKoZIhvcN
AQEBBQADSwAwSAJBAMy8QcW7RMrB4sTdQ8Nmb2DFmJmkWn+el+NdeamI
DElX/qw9mIQu4xNj1FfepfJNxzPvA0OtMKhy6+bkrlyMEU8CAwEAATAN
BgkqhkiG9w0BAQIFAANPAAYn7jDgirhiIL4wnP8nGzUisGSpsFsF4/7z
2P2wqne6Qk8Cg/Dstu3RyaN78vAMGP8d82H5+Ndfhi2mRp4YHiGHz0Hl
K6VbPfnyvS2wdjCCAccwggFRAgUCQAAAFDANBgkqhkiG9w0BAQIFADBf
MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXUlNBIERhdGEgU2VjdXJpdHks
IEluYy4xLjAsBgNVBAsTJUxvdyBBc3N1cmFuY2UgQ2VydGlmaWNhdGlv
biBBdXRob3JpdHkwHhcNOTQwMTA3MDAwMDAwWhcNOTYwMTA3MjM1OTU5
WjBNMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXUlNBIERhdGEgU2VjdXJp
dHksIEluYy4xHDAaBgNVBAsTE1BlcnNvbmEgQ2VydGlmaWNhdGUwaTAN
BgkqhkiG9w0BAQEFAANYADBVAk4GqghQDa9Xi/2zAdYEqJVIcYhlLN1F
pI9tXQ1m6zZ39PYXK8Uhoj0Es7kWRv8hC04vqkOKwndWbzVtvoHQOmP8
nOkkuBi+AQvgFoRcgOUCAwEAATANBgkqhkiG9w0BAQIFAANhAD/5Uo7x
Ddp49oZm9GoNcPhZcW1e+nojLvHXWAU/CBkwfcR+FSf4hQ5eFu1AjYv6
Wqf430Xe9Et5+jgnMTiq4LnwgTdA8xQX4elJz9QzQobkE3XVOjVAtCFc
miin80RB8AAAMYAAAAAAAAAAAA==
-----END xxx-----

11
apps/stuff/pkcs7.ex2
View file

@ -1,11 +0,0 @@
-----BEGIN PRIVACY-ENHANCED MESSAGE-----
MIAGCSqGSIb3DQEHBqCAMIACAQAwgAYJKoZIhvcNAQcBMBEGBSsOAwIHBAifqtdy
x6uIMYCCARgvFzJtOZBn773DtmXlx037ck3giqnV0WC0QAx5f+fesAiGaxMqWcir
r9XvT0nT0LgSQ/8tiLCDBEKdyCNgdcJAduy3D0r2sb5sNTT0TyL9uydG3w55vTnW
aPbCPCWLudArI1UHDZbnoJICrVehxG/sYX069M8v6VO8PsJS7//hh1yM+0nekzQ5
l1p0j7uWKu4W0csrlGqhLvEJanj6dQAGSTNCOoH3jzEXGQXntgesk8poFPfHdtj0
5RH4MuJRajDmoEjlrNcnGl/BdHAd2JaCo6uZWGcnGAgVJ/TVfSVSwN5nlCK87tXl
nL7DJwaPRYwxb3mnPKNq7ATiJPf5u162MbwxrddmiE7e3sST7naSN+GS0ateY5X7
AAAAAAAAAAA=
-----END PRIVACY-ENHANCED MESSAGE-----

12
apps/stuff/pkcs7.ex3
View file

@ -1,12 +0,0 @@
-----BEGIN PRIVACY-ENHANCED MESSAGE-----
MIAGCSqGSIb3DQEHA6CAMIACAQAxgDCBqQIBADBTME0xCzAJBgNVBAYTAlVTMSAw
HgYDVQQKExdSU0EgRGF0YSBTZWN1cml0eSwgSW5jLjEcMBoGA1UECxMTUGVyc29u
YSBDZXJ0aWZpY2F0ZQICALYwDQYJKoZIhvcNAQEBBQAEQCU/R+YCJSUsV6XLilHG
cNVzwqKcWzmT/rZ+duOv8Ggb7oO/d8H3xUVGQ2LsX4kYGq2szwj8Q6eWhsmhf4oz
lvMAADCABgkqhkiG9w0BBwEwEQYFKw4DAgcECFif7BadXlw3oIAEgZBNcMexKe16
+mNxx8YQPukBCL0bWqS86lvws/AgRkKPELmysBi5lco8MBCsWK/fCyrnxIRHs1oK
BXBVlsAhKkkusk1kCf/GbXSAphdSgG+d6LxrNZwHbBFOX6A2hYS63Iczd5bOVDDW
Op2gcgUtMJq6k2LFrs4L7HHqRPPlqNJ6j5mFP4xkzOCNIQynpD1rV6EECMIk/T7k
1JLSAAAAAAAAAAAAAA==
-----END PRIVACY-ENHANCED MESSAGE-----

46
apps/stuff/pkcs7.pem
View file

@ -1,46 +0,0 @@
-----BEGIN PKCS7-----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-----END PKCS7-----

16
apps/test.ssl
View file

@ -1,16 +0,0 @@
www.microsoft.com:443
sectest.microsoft.com:443
https://sectest.microsoft.com/ClientAuth/test.asp
ssl3.netscape.com:443
ssl3.netscape.com:444
www.openmarket.com:443 - no session ID caching. - no swap
Servers
bad www.openmarket.com Open-Market-Secure-WebServer/V2.1
bad www.microsoft.com Server: Microsoft-IIS/3.0
good transact.netscape.com Netscape-Enterprise/2.01
clients
good netscape
hmm MSIE

16
certs/vsign4.pem
View file

@ -1,16 +0,0 @@
subject=/C=US/O=VeriSign, Inc./OU=Class 4 Public Primary Certification Authority
issuer= /C=US/O=VeriSign, Inc./OU=Class 4 Public Primary Certification Authority
-----BEGIN CERTIFICATE-----
MIICMTCCAZoCBQKmAAABMA0GCSqGSIb3DQEBAgUAMF8xCzAJBgNVBAYTAlVTMRcw
FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE3MDUGA1UECxMuQ2xhc3MgNCBQdWJsaWMg
UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05NjAxMjkwMDAwMDBa
Fw05OTEyMzEyMzU5NTlaMF8xCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2ln
biwgSW5jLjE3MDUGA1UECxMuQ2xhc3MgNCBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZp
Y2F0aW9uIEF1dGhvcml0eTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0LJ1
9njQrlpQ9OlQqZ+M1++RlHDo0iSQdomF1t+s5gEXMoDwnZNHvJplnR+Xrr/phnVj
IIm9gFidBAydqMEk6QvlMXi9/C0MN2qeeIDpRnX57aP7E3vIwUzSo+/1PLBij0pd
O92VZ48TucE81qcmm+zDO3rZTbxtm+gVAePwR6kCAwEAATANBgkqhkiG9w0BAQIF
AAOBgQBT3dPwnCR+QKri/AAa19oM/DJhuBUNlvP6Vxt/M3yv6ZiaYch6s7f/sdyZ
g9ysEvxwyR84Qu1E9oAuW2szaayc01znX1oYx7EteQSWQZGZQbE8DbqEOcY7l/Am
yY7uvcxClf8exwI/VAx49byqYHwCaejcrOICdmHEPgPq0ook0Q==
-----END CERTIFICATE-----

117
crypto/asn1/pk.c
View file

@ -1,117 +0,0 @@
/* crypto/asn1/pk.c */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "../error/err.h"
#include "./asn1.h"
#include "rsa.h"
#include "x509.h"
#include "pkcs7.h"
main()
{
PKCS7 *x;
FILE *in;
unsigned char buf[10240],buf2[10240],*p;
int num,i;
PKCS7 *nx=NULL,*mx=NULL;
in=fopen("pkcs7.der","r");
if (in == NULL)
{
perror("pkcs7.der");
exit(1);
}
num=fread(buf,1,10240,in);
fclose(in);
p=buf;
if (d2i_PKCS7(&nx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf);
exit(0);
p=buf2;
num=i2d_PKCS7(nx,&p);
printf("num=%d p-buf=%d\n",num,p-buf2);
if (memcmp(buf,buf2,num) != 0)
{
fprintf(stderr,"data difference\n");
for (i=0; i<num; i++)
fprintf(stderr,"%c%03d <%02X-%02X>\n",
(buf[i] == buf2[i])?' ':'*',i,
buf[i],buf2[i]);
fprintf(stderr,"\n");
exit(1);
}
p=buf2;
if (d2i_PKCS7(&mx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf2);
/* X509_print(stdout,mx);*/
exit(0);
err:
ERR_load_crypto_strings();
ERR_print_errors(stderr);
exit(1);
}

253
crypto/asn1/test.c
View file

@ -1,253 +0,0 @@
/* crypto/asn1/test.c */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "../error/err.h"
#include "./asn1.h"
#include "rsa.h"
#include "../x509/x509.h"
#include "x509.h"
main()
{
main1();
main2();
main3();
main4();
}
main1()
{
FILE *in;
unsigned char buf[10240],buf2[10240],*p;
int num,i;
X509 *nx=NULL,*mx=NULL;
in=fopen("x.der","r");
if (in == NULL)
{
perror("x.der");
exit(1);
}
num=fread(buf,1,10240,in);
fclose(in);
p=buf;
if (d2i_X509(&nx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf);
p=buf2;
num=i2d_X509(nx,&p);
printf("num=%d p-buf=%d\n",num,p-buf2);
if (memcmp(buf,buf2,num) != 0)
{
fprintf(stderr,"data difference\n");
for (i=0; i<num; i++)
fprintf(stderr,"%c%03d <%02X-%02X>\n",
(buf[i] == buf2[i])?' ':'*',i,
buf[i],buf2[i]);
fprintf(stderr,"\n");
exit(1);
}
p=buf2;
if (d2i_X509(&mx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf2);
return(1);
err:
ERR_load_crypto_strings();
ERR_print_errors(stderr);
return(0);
}
main2()
{
FILE *in;
unsigned char buf[10240],buf2[10240],*p;
int num,i;
X509_CRL *nx=NULL,*mx=NULL;
in=fopen("crl.der","r");
if (in == NULL)
{
perror("crl.der");
exit(1);
}
num=fread(buf,1,10240,in);
fclose(in);
p=buf;
if (d2i_X509_CRL(&nx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf);
p=buf2;
num=i2d_X509_CRL(nx,&p);
printf("num=%d p-buf=%d\n",num,p-buf2);
if (memcmp(buf,buf2,num) != 0)
{
fprintf(stderr,"data difference\n");
for (i=0; i<num; i++)
fprintf(stderr,"%c%03d <%02X-%02X>\n",
(buf[i] == buf2[i])?' ':'*',i,
buf[i],buf2[i]);
fprintf(stderr,"\n");
exit(1);
}
return(1);
err:
ERR_load_crypto_strings();
ERR_print_errors(stderr);
return(0);
}
main3()
{
FILE *in;
unsigned char buf[10240],buf2[10240],*p;
int num,i;
X509_REQ *nx=NULL,*mx=NULL;
in=fopen("req.der","r");
if (in == NULL)
{
perror("req.der");
exit(1);
}
num=fread(buf,1,10240,in);
fclose(in);
p=buf;
if (d2i_X509_REQ(&nx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf);
p=buf2;
num=i2d_X509_REQ(nx,&p);
printf("num=%d p-buf=%d\n",num,p-buf2);
if (memcmp(buf,buf2,num) != 0)
{
fprintf(stderr,"data difference\n");
for (i=0; i<num; i++)
fprintf(stderr,"%c%03d <%02X-%02X>\n",
(buf[i] == buf2[i])?' ':'*',i,
buf[i],buf2[i]);
fprintf(stderr,"\n");
exit(1);
}
return(1);
err:
ERR_load_crypto_strings();
ERR_print_errors(stderr);
return(0);
}
main4()
{
FILE *in;
unsigned char buf[10240],buf2[10240],*p;
int num,i;
RSA *nx=NULL,*mx=NULL;
in=fopen("rsa.der","r");
if (in == NULL)
{
perror("rsa.der");
exit(1);
}
num=fread(buf,1,10240,in);
fclose(in);
p=buf;
if (d2i_RSAPrivateKey(&nx,&p,num) == NULL) goto err;
printf("num=%d p-buf=%d\n",num,p-buf);
p=buf2;
num=i2d_RSAPrivateKey(nx,&p);
printf("num=%d p-buf=%d\n",num,p-buf2);
if (memcmp(buf,buf2,num) != 0)
{
fprintf(stderr,"data difference\n");
for (i=0; i<num; i++)
fprintf(stderr,"%c%03d <%02X-%02X>\n",
(buf[i] == buf2[i])?' ':'*',i,
buf[i],buf2[i]);
fprintf(stderr,"\n");
exit(1);
}
return(1);
err:
ERR_load_crypto_strings();
ERR_print_errors(stderr);
return(0);
}

666
crypto/bf/asm/bx86-cpp.s
View file

@ -1,666 +0,0 @@
/* Don't even think of reading this code */
/* It was automatically generated by bf586.pl */
/* Which is a perl program used to generate the x86 assember for */
/* any of elf, a.out, Win32, or Solaris */
/* It can be found in SSLeay 0.7.0+ */
/* eric <eay@cryptsoft.com> */
.file "bfx86xxxx.s"
.version "01.01"
gcc2_compiled.:
.text
.align ALIGN
.globl BF_encrypt
TYPE(BF_encrypt,@function)
BF_encrypt:
pushl %ebp
pushl %ebx
pushl %esi
pushl %edi
/* Load the 2 words */
movl 20(%esp), %eax
movl (%eax), %ecx
movl 4(%eax), %edx
/* P pointer, s and enc flag */
movl 24(%esp), %edi
xorl %eax, %eax
xorl %ebx, %ebx
movl 28(%esp), %ebp
cmpl $0, %ebp
je .L000start_decrypt
xorl (%edi), %ecx
/* Round 0 */
rorl $16, %ecx
movl 4(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 1 */
rorl $16, %edx
movl 8(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 2 */
rorl $16, %ecx
movl 12(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 3 */
rorl $16, %edx
movl 16(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 4 */
rorl $16, %ecx
movl 20(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 5 */
rorl $16, %edx
movl 24(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 6 */
rorl $16, %ecx
movl 28(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 7 */
rorl $16, %edx
movl 32(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 8 */
rorl $16, %ecx
movl 36(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 9 */
rorl $16, %edx
movl 40(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 10 */
rorl $16, %ecx
movl 44(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 11 */
rorl $16, %edx
movl 48(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 12 */
rorl $16, %ecx
movl 52(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 13 */
rorl $16, %edx
movl 56(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 14 */
rorl $16, %ecx
movl 60(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 15 */
rorl $16, %edx
movl 64(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
xorl 68(%edi), %edx
movl 20(%esp), %eax
movl %edx, (%eax)
movl %ecx, 4(%eax)
popl %edi
popl %esi
popl %ebx
popl %ebp
ret
.align ALIGN
.L000start_decrypt:
xorl 68(%edi), %ecx
/* Round 16 */
rorl $16, %ecx
movl 64(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 15 */
rorl $16, %edx
movl 60(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 14 */
rorl $16, %ecx
movl 56(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 13 */
rorl $16, %edx
movl 52(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 12 */
rorl $16, %ecx
movl 48(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 11 */
rorl $16, %edx
movl 44(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 10 */
rorl $16, %ecx
movl 40(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 9 */
rorl $16, %edx
movl 36(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 8 */
rorl $16, %ecx
movl 32(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 7 */
rorl $16, %edx
movl 28(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 6 */
rorl $16, %ecx
movl 24(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 5 */
rorl $16, %edx
movl 20(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 4 */
rorl $16, %ecx
movl 16(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 3 */
rorl $16, %edx
movl 12(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
/* Round 2 */
rorl $16, %ecx
movl 8(%edi), %esi
movb %ch, %al
movb %cl, %bl
rorl $16, %ecx
xorl %esi, %edx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %ch, %al
movb %cl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %edx
/* Round 1 */
rorl $16, %edx
movl 4(%edi), %esi
movb %dh, %al
movb %dl, %bl
rorl $16, %edx
xorl %esi, %ecx
movl 72(%edi,%eax,4),%esi
movl 1096(%edi,%ebx,4),%ebp
movb %dh, %al
movb %dl, %bl
addl %ebp, %esi
movl 2120(%edi,%eax,4),%eax
xorl %eax, %esi
movl 3144(%edi,%ebx,4),%ebp
addl %ebp, %esi
xorl %eax, %eax
xorl %esi, %ecx
xorl (%edi), %edx
movl 20(%esp), %eax
movl %edx, (%eax)
movl %ecx, 4(%eax)
popl %edi
popl %esi
popl %ebx
popl %ebp
ret
.BF_encrypt_end:
SIZE(BF_encrypt,.BF_encrypt_end-BF_encrypt)
.ident "desasm.pl"

663
crypto/bf/asm/win32.asm
View file

@ -1,663 +0,0 @@
; Don't even think of reading this code
; It was automatically generated by bf586.pl
; Which is a perl program used to generate the x86 assember for
; any of elf, a.out, Win32, or Solaris
; It can be found in SSLeay 0.7.0+
; eric <eay@cryptsoft.com>
;
TITLE bfx86xxxx.asm
.386
.model FLAT
_TEXT SEGMENT
PUBLIC _BF_encrypt
EXTRN _des_SPtrans:DWORD
_BF_encrypt PROC NEAR
push ebp
push ebx
push esi
push edi
;
; Load the 2 words
mov eax, DWORD PTR 20[esp]
mov ecx, DWORD PTR [eax]
mov edx, DWORD PTR 4[eax]
;
; P pointer, s and enc flag
mov edi, DWORD PTR 24[esp]
xor eax, eax
xor ebx, ebx
mov ebp, DWORD PTR 28[esp]
cmp ebp, 0
je $L000start_decrypt
xor ecx, DWORD PTR [edi]
;
; Round 0
ror ecx, 16
mov esi, DWORD PTR 4[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 1
ror edx, 16
mov esi, DWORD PTR 8[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 2
ror ecx, 16
mov esi, DWORD PTR 12[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 3
ror edx, 16
mov esi, DWORD PTR 16[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 4
ror ecx, 16
mov esi, DWORD PTR 20[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 5
ror edx, 16
mov esi, DWORD PTR 24[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 6
ror ecx, 16
mov esi, DWORD PTR 28[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 7
ror edx, 16
mov esi, DWORD PTR 32[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 8
ror ecx, 16
mov esi, DWORD PTR 36[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 9
ror edx, 16
mov esi, DWORD PTR 40[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 10
ror ecx, 16
mov esi, DWORD PTR 44[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 11
ror edx, 16
mov esi, DWORD PTR 48[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 12
ror ecx, 16
mov esi, DWORD PTR 52[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 13
ror edx, 16
mov esi, DWORD PTR 56[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 14
ror ecx, 16
mov esi, DWORD PTR 60[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 15
ror edx, 16
mov esi, DWORD PTR 64[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
xor edx, DWORD PTR 68[edi]
mov eax, DWORD PTR 20[esp]
mov DWORD PTR [eax],edx
mov DWORD PTR 4[eax],ecx
pop edi
pop esi
pop ebx
pop ebp
ret
$L000start_decrypt:
xor ecx, DWORD PTR 68[edi]
;
; Round 16
ror ecx, 16
mov esi, DWORD PTR 64[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 15
ror edx, 16
mov esi, DWORD PTR 60[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 14
ror ecx, 16
mov esi, DWORD PTR 56[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 13
ror edx, 16
mov esi, DWORD PTR 52[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 12
ror ecx, 16
mov esi, DWORD PTR 48[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 11
ror edx, 16
mov esi, DWORD PTR 44[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 10
ror ecx, 16
mov esi, DWORD PTR 40[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 9
ror edx, 16
mov esi, DWORD PTR 36[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 8
ror ecx, 16
mov esi, DWORD PTR 32[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 7
ror edx, 16
mov esi, DWORD PTR 28[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 6
ror ecx, 16
mov esi, DWORD PTR 24[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 5
ror edx, 16
mov esi, DWORD PTR 20[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 4
ror ecx, 16
mov esi, DWORD PTR 16[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 3
ror edx, 16
mov esi, DWORD PTR 12[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
;
; Round 2
ror ecx, 16
mov esi, DWORD PTR 8[edi]
mov al, ch
mov bl, cl
ror ecx, 16
xor edx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, ch
mov bl, cl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor edx, esi
;
; Round 1
ror edx, 16
mov esi, DWORD PTR 4[edi]
mov al, dh
mov bl, dl
ror edx, 16
xor ecx, esi
mov esi, DWORD PTR 72[eax*4+edi]
mov ebp, DWORD PTR 1096[ebx*4+edi]
mov al, dh
mov bl, dl
add esi, ebp
mov eax, DWORD PTR 2120[eax*4+edi]
xor esi, eax
mov ebp, DWORD PTR 3144[ebx*4+edi]
add esi, ebp
xor eax, eax
xor ecx, esi
xor edx, DWORD PTR [edi]
mov eax, DWORD PTR 20[esp]
mov DWORD PTR [eax],edx
mov DWORD PTR 4[eax],ecx
pop edi
pop esi
pop ebx
pop ebp
ret
_BF_encrypt ENDP
_TEXT ENDS
END

272
crypto/bn/asm/x86-bsdi.s
View file

@ -1,272 +0,0 @@
.file "bn_mulw.c"
.version "01.01"
gcc2_compiled.:
.text
.align 4
.globl _bn_mul_add_word
_bn_mul_add_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
# ax L(t)
# dx H(t)
# bx a
# cx w
# di r
# si c
# bp num
xorl %esi,%esi # c=0
movl 20(%esp),%edi # r => edi
movl 24(%esp),%ebx # a => exb
movl 32(%esp),%ecx # w => ecx
movl 28(%esp),%ebp # num => ebp
shrl $2,%ebp # num/4
je .L910
# .align 4
.L110:
# Round 1
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl (%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+= carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 2
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl 4(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+= carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 3
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl 8(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 4
movl %ecx,%eax # w => eax
mull 12(%ebx) # w * *a
addl 12(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,12(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
addl $16,%ebx # a+=4 (4 words)
addl $16,%edi # r+=4 (4 words)
decl %ebp # --num
je .L910
jmp .L110
# .align 4
.L910:
movl 28(%esp),%ebp # num => ebp
andl $3,%ebp
je .L111
# Round 1
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl (%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L111
# Round 2
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl 4(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L111
# Round 3
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl 8(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# .align 4
.L111:
movl %esi,%eax # return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe1:
.align 4
.globl _bn_mul_word
_bn_mul_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
# ax L(t)
# dx H(t)
# bx a
# cx w
# di r
# num bp
# si c
xorl %esi,%esi # c=0
movl 20(%esp),%edi # r => edi
movl 24(%esp),%ebx # a => exb
movl 28(%esp),%ebp # num => bp
movl 32(%esp),%ecx # w => ecx
# .align 4
.L210:
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 12(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,12(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
addl $16,%ebx # a+=4 (4 words)
addl $16,%edi # r+=4 (4 words)
jmp .L210
# .align 4
.L211:
movl %esi,%eax # return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe2:
.align 4
.globl _bn_sqr_words
_bn_sqr_words:
pushl %edi
pushl %esi
pushl %ebx
movl 16(%esp),%esi # r
movl 20(%esp),%edi # a
movl 24(%esp),%ebx # n
# .align 4
shrl $2,%ebx
jz .L99
.L28:
movl (%edi),%eax # get a
mull %eax # a*a
movl %eax,(%esi) # put low into return addr
movl %edx,4(%esi) # put high into return addr
movl 4(%edi),%eax # get a
mull %eax # a*a
movl %eax,8(%esi) # put low into return addr
movl %edx,12(%esi) # put high into return addr
movl 8(%edi),%eax # get a
mull %eax # a*a
movl %eax,16(%esi) # put low into return addr
movl %edx,20(%esi) # put high into return addr
movl 12(%edi),%eax # get a
mull %eax # a*a
movl %eax,24(%esi) # put low into return addr
movl %edx,28(%esi) # put high into return addr
addl $16,%edi
addl $32,%esi
decl %ebx # n-=4;
jz .L99
jmp .L28
# .align 4
.L99:
movl 24(%esp),%ebx # n
andl $3,%ebx
jz .L29
movl (%edi),%eax # get a
mull %eax # a*a
movl %eax,(%esi) # put low into return addr
movl %edx,4(%esi) # put high into return addr
decl %ebx # n--;
jz .L29
movl 4(%edi),%eax # get a
mull %eax # a*a
movl %eax,8(%esi) # put low into return addr
movl %edx,12(%esi) # put high into return addr
decl %ebx # n--;
jz .L29
movl 8(%edi),%eax # get a
mull %eax # a*a
movl %eax,16(%esi) # put low into return addr
movl %edx,20(%esi) # put high into return addr
.L29:
popl %ebx
popl %esi
popl %edi
ret
.Lfe3:
.align 4
.globl _bn_div64
_bn_div64:
movl 4(%esp),%edx # a
movl 8(%esp),%eax # b
divl 12(%esp) # ab/c
ret
.Lfe4:
.ident "GCC: (GNU) 2.6.3"

282
crypto/bn/asm/x86-lnx.s
View file

@ -1,282 +0,0 @@
.file "bn_mulw.c"
.version "01.01"
gcc2_compiled.:
.text
.align 16
.globl bn_mul_add_word
.type bn_mul_add_word,@function
bn_mul_add_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
# ax L(t)
# dx H(t)
# bx a
# cx w
# di r
# si c
# bp num
xorl %esi,%esi # c=0
movl 20(%esp),%edi # r => edi
movl 24(%esp),%ebx # a => exb
movl 32(%esp),%ecx # w => ecx
movl 28(%esp),%ebp # num => ebp
shrl $2,%ebp # num/4
je .L910
.align 4
.L110:
# Round 1
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl (%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+= carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 2
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl 4(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+= carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 3
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl 8(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 4
movl %ecx,%eax # w => eax
mull 12(%ebx) # w * *a
addl 12(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,12(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
addl $16,%ebx # a+=4 (4 words)
addl $16,%edi # r+=4 (4 words)
decl %ebp # --num
je .L910
jmp .L110
.align 4
.L910:
movl 28(%esp),%ebp # num => ebp
andl $3,%ebp
je .L111
# Round 1
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl (%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L111
# Round 2
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl 4(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L111
# Round 3
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl 8(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
.align 4
.L111:
movl %esi,%eax # return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe1:
.size bn_mul_add_word,.Lfe1-bn_mul_add_word
.align 16
.globl bn_mul_word
.type bn_mul_word,@function
bn_mul_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
# ax L(t)
# dx H(t)
# bx a
# cx w
# di r
# num bp
# si c
xorl %esi,%esi # c=0
movl 20(%esp),%edi # r => edi
movl 24(%esp),%ebx # a => exb
movl 28(%esp),%ebp # num => bp
movl 32(%esp),%ecx # w => ecx
.align 4
.L210:
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 12(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,12(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
addl $16,%ebx # a+=4 (4 words)
addl $16,%edi # r+=4 (4 words)
jmp .L210
.align 16
.L211:
movl %esi,%eax # return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe2:
.size bn_mul_word,.Lfe2-bn_mul_word
.align 16
.globl bn_sqr_words
.type bn_sqr_words,@function
bn_sqr_words:
pushl %edi
pushl %esi
pushl %ebx
movl 16(%esp),%esi # r
movl 20(%esp),%edi # a
movl 24(%esp),%ebx # n
.align 4
shrl $2,%ebx
jz .L99
.L28:
movl (%edi),%eax # get a
mull %eax # a*a
movl %eax,(%esi) # put low into return addr
movl %edx,4(%esi) # put high into return addr
movl 4(%edi),%eax # get a
mull %eax # a*a
movl %eax,8(%esi) # put low into return addr
movl %edx,12(%esi) # put high into return addr
movl 8(%edi),%eax # get a
mull %eax # a*a
movl %eax,16(%esi) # put low into return addr
movl %edx,20(%esi) # put high into return addr
movl 12(%edi),%eax # get a
mull %eax # a*a
movl %eax,24(%esi) # put low into return addr
movl %edx,28(%esi) # put high into return addr
addl $16,%edi
addl $32,%esi
decl %ebx # n-=4;
jz .L99
jmp .L28
.align 16
.L99:
movl 24(%esp),%ebx # n
andl $3,%ebx
jz .L29
movl (%edi),%eax # get a
mull %eax # a*a
movl %eax,(%esi) # put low into return addr
movl %edx,4(%esi) # put high into return addr
decl %ebx # n--;
jz .L29
movl 4(%edi),%eax # get a
mull %eax # a*a
movl %eax,8(%esi) # put low into return addr
movl %edx,12(%esi) # put high into return addr
decl %ebx # n--;
jz .L29
movl 8(%edi),%eax # get a
mull %eax # a*a
movl %eax,16(%esi) # put low into return addr
movl %edx,20(%esi) # put high into return addr
.L29:
popl %ebx
popl %esi
popl %edi
ret
.Lfe3:
.size bn_sqr_words,.Lfe3-bn_sqr_words
.align 16
.globl bn_div64
.type bn_div64,@function
bn_div64:
movl 4(%esp),%edx # a
movl 8(%esp),%eax # b
divl 12(%esp) # ab/c
ret
.Lfe4:
.size bn_div64,.Lfe4-bn_div64
.ident "GCC: (GNU) 2.6.3"

282
crypto/bn/asm/x86-lnxa.s
View file

@ -1,282 +0,0 @@
.file "bn_mulw.c"
.version "01.01"
gcc2_compiled.:
.text
.align 4
.globl _bn_mul_add_word
.type _bn_mul_add_word,@function
_bn_mul_add_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
# ax L(t)
# dx H(t)
# bx a
# cx w
# di r
# si c
# bp num
xorl %esi,%esi # c=0
movl 20(%esp),%edi # r => edi
movl 24(%esp),%ebx # a => exb
movl 32(%esp),%ecx # w => ecx
movl 28(%esp),%ebp # num => ebp
shrl $2,%ebp # num/4
je .L910
# .align 4
.L110:
# Round 1
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl (%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+= carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 2
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl 4(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+= carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 3
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl 8(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# Round 4
movl %ecx,%eax # w => eax
mull 12(%ebx) # w * *a
addl 12(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,12(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
addl $16,%ebx # a+=4 (4 words)
addl $16,%edi # r+=4 (4 words)
decl %ebp # --num
je .L910
jmp .L110
# .align 4
.L910:
movl 28(%esp),%ebp # num => ebp
andl $3,%ebp
je .L111
# Round 1
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl (%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L111
# Round 2
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl 4(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L111
# Round 3
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl 8(%edi),%eax # *r+=L(t)
adcl $0,%edx # H(t)+=carry
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r+=L(t)
movl %edx,%esi # c=H(t)
# .align 4
.L111:
movl %esi,%eax # return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe1:
.size _bn_mul_add_word,.Lfe1-_bn_mul_add_word
.align 4
.globl _bn_mul_word
.type _bn_mul_word,@function
_bn_mul_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
# ax L(t)
# dx H(t)
# bx a
# cx w
# di r
# num bp
# si c
xorl %esi,%esi # c=0
movl 20(%esp),%edi # r => edi
movl 24(%esp),%ebx # a => exb
movl 28(%esp),%ebp # num => bp
movl 32(%esp),%ecx # w => ecx
# .align 4
.L210:
movl %ecx,%eax # w => eax
mull (%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 4(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,4(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 8(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,8(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
movl %ecx,%eax # w => eax
mull 12(%ebx) # w * *a
addl %esi,%eax # L(t)+=c
adcl $0,%edx # H(t)+=carry
movl %eax,12(%edi) # *r=L(t)
movl %edx,%esi # c=H(t)
decl %ebp # --num
je .L211
addl $16,%ebx # a+=4 (4 words)
addl $16,%edi # r+=4 (4 words)
jmp .L210
# .align 4
.L211:
movl %esi,%eax # return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe2:
.size _bn_mul_word,.Lfe2-_bn_mul_word
.align 4
.globl _bn_sqr_words
.type _bn_sqr_words,@function
_bn_sqr_words:
pushl %edi
pushl %esi
pushl %ebx
movl 16(%esp),%esi # r
movl 20(%esp),%edi # a
movl 24(%esp),%ebx # n
# .align 4
shrl $2,%ebx
jz .L99
.L28:
movl (%edi),%eax # get a
mull %eax # a*a
movl %eax,(%esi) # put low into return addr
movl %edx,4(%esi) # put high into return addr
movl 4(%edi),%eax # get a
mull %eax # a*a
movl %eax,8(%esi) # put low into return addr
movl %edx,12(%esi) # put high into return addr
movl 8(%edi),%eax # get a
mull %eax # a*a
movl %eax,16(%esi) # put low into return addr
movl %edx,20(%esi) # put high into return addr
movl 12(%edi),%eax # get a
mull %eax # a*a
movl %eax,24(%esi) # put low into return addr
movl %edx,28(%esi) # put high into return addr
addl $16,%edi
addl $32,%esi
decl %ebx # n-=4;
jz .L99
jmp .L28
# .align 4
.L99:
movl 24(%esp),%ebx # n
andl $3,%ebx
jz .L29
movl (%edi),%eax # get a
mull %eax # a*a
movl %eax,(%esi) # put low into return addr
movl %edx,4(%esi) # put high into return addr
decl %ebx # n--;
jz .L29
movl 4(%edi),%eax # get a
mull %eax # a*a
movl %eax,8(%esi) # put low into return addr
movl %edx,12(%esi) # put high into return addr
decl %ebx # n--;
jz .L29
movl 8(%edi),%eax # get a
mull %eax # a*a
movl %eax,16(%esi) # put low into return addr
movl %edx,20(%esi) # put high into return addr
.L29:
popl %ebx
popl %esi
popl %edi
ret
.Lfe3:
.size _bn_sqr_words,.Lfe3-_bn_sqr_words
.align 4
.globl _bn_div64
.type _bn_div64,@function
_bn_div64:
movl 4(%esp),%edx # a
movl 8(%esp),%eax # b
divl 12(%esp) # ab/c
ret
.Lfe4:
.size _bn_div64,.Lfe4-_bn_div64
.ident "GCC: (GNU) 2.6.3"

224
crypto/bn/asm/x86-sol.s
View file

@ -1,224 +0,0 @@
.file "bn_mulw.c"
.version "01.01"
gcc2_compiled.:
.text
.align 16
.globl bn_mul_add_word
.type bn_mul_add_word,@function
bn_mul_add_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
/ ax L(t)
/ dx H(t)
/ bx a
/ cx w
/ di r
/ si c
/ bp num
xorl %esi,%esi / c=0
movl 20(%esp),%edi / r => edi
movl 24(%esp),%ebx / a => exb
movl 28(%esp),%ebp / num => ebp
movl 32(%esp),%ecx / w => ecx
.align 4
.L110:
movl %ecx,%eax / w => eax
mull (%ebx) / w * *a
addl (%edi),%eax / L(t)+= *r
adcl $0,%edx / H(t)+= carry
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L111
movl %ecx,%eax / w => eax
mull 4(%ebx) / w * *a
addl 4(%edi),%eax / L(t)+= *r
adcl $0,%edx / H(t)+= carry
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,4(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L111
movl %ecx,%eax / w => eax
mull 8(%ebx) / w * *a
addl 8(%edi),%eax / L(t)+= *r
adcl $0,%edx / H(t)+= carry
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,8(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L111
movl %ecx,%eax / w => eax
mull 12(%ebx) / w * *a
addl 12(%edi),%eax / L(t)+= *r
adcl $0,%edx / H(t)+= carry
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,12(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L111
addl $16,%ebx / a+=4 (4 words)
addl $16,%edi / r+=4 (4 words)
jmp .L110
.align 16
.L111:
movl %esi,%eax / return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe1:
.size bn_mul_add_word,.Lfe1-bn_mul_add_word
.align 16
.globl bn_mul_word
.type bn_mul_word,@function
bn_mul_word:
pushl %ebp
pushl %edi
pushl %esi
pushl %ebx
/ ax L(t)
/ dx H(t)
/ bx a
/ cx w
/ di r
/ num bp
/ si c
xorl %esi,%esi / c=0
movl 20(%esp),%edi / r => edi
movl 24(%esp),%ebx / a => exb
movl 28(%esp),%ebp / num => ebp
movl 32(%esp),%ecx / w => ecx
.align 4
.L210:
movl %ecx,%eax / w => eax
mull (%ebx) / w * *a
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L211
movl %ecx,%eax / w => eax
mull 4(%ebx) / w * *a
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,4(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L211
movl %ecx,%eax / w => eax
mull 8(%ebx) / w * *a
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,8(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L211
movl %ecx,%eax / w => eax
mull 12(%ebx) / w * *a
addl %esi,%eax / L(t)+=c
adcl $0,%edx / H(t)+=carry
movl %eax,12(%edi) / *r=L(t)
movl %edx,%esi / c=H(t)
decl %ebp / --num
je .L211
addl $16,%ebx / a+=4 (4 words)
addl $16,%edi / r+=4 (4 words)
jmp .L210
.align 16
.L211:
movl %esi,%eax / return(c)
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.Lfe2:
.size bn_mul_word,.Lfe2-bn_mul_word
.align 16
.globl bn_sqr_words
.type bn_sqr_words,@function
bn_sqr_words:
pushl %edi
pushl %esi
pushl %ebx
movl 16(%esp),%esi / r
movl 20(%esp),%edi / a
movl 24(%esp),%ebx / n
.align 4
.L28:
movl (%edi),%eax / get a
mull %eax / a*a
movl %eax,(%esi) / put low into return addr
movl %edx,4(%esi) / put high into return addr
decl %ebx / n--;
je .L29
movl 4(%edi),%eax / get a
mull %eax / a*a
movl %eax,8(%esi) / put low into return addr
movl %edx,12(%esi) / put high into return addr
decl %ebx / n--;
je .L29
movl 8(%edi),%eax / get a
mull %eax / a*a
movl %eax,16(%esi) / put low into return addr
movl %edx,20(%esi) / put high into return addr
decl %ebx / n--;
je .L29
movl 12(%edi),%eax / get a
mull %eax / a*a
movl %eax,24(%esi) / put low into return addr
movl %edx,28(%esi) / put high into return addr
decl %ebx / n--;
je .L29
addl $16,%edi
addl $32,%esi
jmp .L28
.align 16
.L29:
popl %ebx
popl %esi
popl %edi
ret
.Lfe3:
.size bn_sqr_words,.Lfe3-bn_sqr_words
.align 16
.globl bn_div64
.type bn_div64,@function
bn_div64:
movl 4(%esp),%edx / a
movl 8(%esp),%eax / b
divl 12(%esp) / ab/c
ret
.Lfe4:
.size bn_div64,.Lfe4-bn_div64
.ident "GCC: (GNU) 2.6.3"

288
crypto/bn/asm/x86nt32.asm
View file

@ -1,288 +0,0 @@
TITLE bn_mulw.c
.386P
.model FLAT
PUBLIC _bn_mul_add_word
_TEXT SEGMENT
; File bn_mulw.c
_bn_mul_add_word PROC NEAR
push ebp
push ebx
push esi
push edi
mov edi,DWORD PTR 20[esp] ; r
mov ebx,DWORD PTR 24[esp] ; a
mov ecx,DWORD PTR 32[esp] ; w
xor esi,esi ; c=0
mov ebp,DWORD PTR 28[esp] ; num
shr ebp,2 ; num/4
jz $L666
$L546:
; Round one
mov eax,DWORD PTR [ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR [edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR [edi],eax ; *r+=ax
mov esi,edx ; c = overflow
; Round two
mov eax,DWORD PTR 4[ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR 4[edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR 4[edi],eax ; *r+=ax
mov esi,edx ; c = overflow
; Round three
mov eax,DWORD PTR 8[ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR 8[edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR 8[edi],eax ; *r+=ax
mov esi,edx ; c = overflow
; Round four
mov eax,DWORD PTR 12[ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR 12[edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR 12[edi],eax ; *r+=ax
mov esi,edx ; c = overflow
add ebx,16
add edi,16
dec ebp
jz $L666
jmp $L546
$L666:
mov ebp,DWORD PTR 28[esp] ; num
and ebp,3 ; num%4
jz $L547
; Round one
mov eax,DWORD PTR [ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR [edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR [edi],eax ; *r+=ax
mov esi,edx ; c = overflow
dec ebp
jz $L547
; Round two
mov eax,DWORD PTR 4[ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR 4[edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR 4[edi],eax ; *r+=ax
mov esi,edx ; c = overflow
dec ebp
jz $L547
; Round three
mov eax,DWORD PTR 8[ebx] ; edx:eax = *a * w
mul ecx
add eax,DWORD PTR 8[edi] ; *r+=ax
adc edx,0
add eax,esi ; edx:eax += c
adc edx,0
mov DWORD PTR 8[edi],eax ; *r+=ax
mov esi,edx ; c = overflow
$L547:
mov eax,esi
pop edi
pop esi
pop ebx
pop ebp
ret
_bn_mul_add_word ENDP
_TEXT ENDS
PUBLIC _bn_mul_word
_TEXT SEGMENT
_bn_mul_word PROC NEAR
push ebp
push ebx
push esi
push edi
mov edi,DWORD PTR 20[esp] ; r
mov ebx,DWORD PTR 24[esp] ; a
mov ebp,DWORD PTR 28[esp] ; num
mov ecx,DWORD PTR 32[esp] ; w
xor esi,esi ; c=0
shr ebp,2 ; num/4
jz $L266
$L593:
; Round one
mov eax,DWORD PTR [ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR [edi],eax ; *r=eax
mov esi,edx ; c=edx
; Round two
mov eax,DWORD PTR 4[ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR 4[edi],eax ; *r=eax
mov esi,edx ; c=edx
; Round three
mov eax,DWORD PTR 8[ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR 8[edi],eax ; *r=eax
mov esi,edx ; c=edx
; Round four
mov eax,DWORD PTR 12[ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR 12[edi],eax ; *r=eax
mov esi,edx ; c=edx
add ebx,16
add edi,16
dec ebp
jz $L266
jmp $L593
$L266:
mov ebp,DWORD PTR 28[esp] ; num
and ebp,3
jz $L601
; Round one
mov eax,DWORD PTR [ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR [edi],eax ; *r=eax
mov esi,edx ; c=edx
dec ebp
jz $L601
; Round two
mov eax,DWORD PTR 4[ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR 4[edi],eax ; *r=eax
mov esi,edx ; c=edx
dec ebp
jz $L601
; Round three
mov eax,DWORD PTR 8[ebx] ; edx:eax= w * *a
mul ecx
add eax,esi ; edx:eax+=c
adc edx,0
mov DWORD PTR 8[edi],eax ; *r=eax
mov esi,edx ; c=edx
$L601:
mov eax,esi
pop edi
pop esi
pop ebx
pop ebp
ret
_bn_mul_word ENDP
_TEXT ENDS
PUBLIC _bn_sqr_words
_TEXT SEGMENT
_bn_sqr_words PROC NEAR
push ebx
push esi
push edi
mov esi,DWORD PTR 16[esp] ; r
mov edi,DWORD PTR 20[esp] ; a
mov ebx,DWORD PTR 24[esp] ; num
shr ebx,2 ; num/4
jz $L111
$L640:
; Round 1
mov eax, DWORD PTR [edi]
mul eax ; *a * *a
mov DWORD PTR [esi],eax
mov DWORD PTR 4[esi],edx
; Round 2
mov eax, DWORD PTR 4[edi]
mul eax ; *a * *a
mov DWORD PTR 8[esi],eax
mov DWORD PTR 12[esi],edx
; Round 3
mov eax, DWORD PTR 8[edi]
mul eax ; *a * *a
mov DWORD PTR 16[esi],eax
mov DWORD PTR 20[esi],edx
; Round 4
mov eax, DWORD PTR 12[edi]
mul eax ; *a * *a
mov DWORD PTR 24[esi],eax
mov DWORD PTR 28[esi],edx
add edi,16
add esi,32
dec ebx
jz $L111
jmp $L640
$L111:
mov ebx,DWORD PTR 24[esp] ; num
and ebx,3 ; num%3
jz $L645
; Round 1
mov eax, DWORD PTR [edi]
mul eax ; *a * *a
mov DWORD PTR [esi],eax
mov DWORD PTR 4[esi],edx
dec ebx
jz $L645
; Round 2
mov eax, DWORD PTR 4[edi]
mul eax ; *a * *a
mov DWORD PTR 8[esi],eax
mov DWORD PTR 12[esi],edx
dec ebx
jz $L645
; Round 3
mov eax, DWORD PTR 8[edi]
mul eax ; *a * *a
mov DWORD PTR 16[esi],eax
mov DWORD PTR 20[esi],edx
$L645:
pop edi
pop esi
pop ebx
ret
_bn_sqr_words ENDP
_TEXT ENDS
PUBLIC _bn_div64
_TEXT SEGMENT
_bn_div64 PROC NEAR
mov edx, DWORD PTR 4[esp]
mov eax, DWORD PTR 8[esp]
div DWORD PTR 12[esp]
ret
_bn_div64 ENDP
_TEXT ENDS
END

144
crypto/bn/bn_bld.c
View file

@ -1,144 +0,0 @@
/* crypto/bn/bn_bld.c */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "cryptlib.h"
#include "bn_lcl.h"
BN_BL_CTX *BN_BL_CTX_new()
{
BN_BL_CTX *ret;
if ((ret=(BN_BL_CTX *)Malloc(sizeof(BN_BL_CTX))) == NULL)
{
BNerr(BN_F_BN_BL_CTX_NEW,ERR_R_MALLOC_FAILURE);
return(NULL);
}
if ((ret->num=BN_new()) == NULL) goto err;
if ((ret->mod=BN_new()) == NULL) goto err;
ret->inum=NULL;
ret->count=16;
ret->count=1;
return(ret);
}
int BN_BL_CTX_Init(a,mod)
BN_BL_CTX *a;
BIGNUM *mod;
{
int i;
BN_CTX *ctx;
if ((ctx=BN_CTX_new()) == NULL) goto m_err;
if (BN_copy(a->mod,mod) == NULL) goto err;
i=BN_num_bits(mod);
if (!BN_rand(a->num,i,1,0)) goto err;
if (a->inum != NULL) BN_clear_free(a->inum);
a->inum=BN_mod_inverse(a->num,a->mod,ctx)
ret->count=16;
return(1);
m_err:
BNerr(BN_F_BN_BL_CTX_INIT,ERR_R_MALLOC_FAILURE);
err:
return(0);
}
BN_BL_CTX *BN_BL_CTX_Update(a)
BN_BL_CTX *a;
{
BN_CTX *ctx;
BN_BL_CTX *new;
if (--a->count > 0)
return(1);
new=BN_BL_CTX_new();
/* set/get lock */
if ((ctx=BN_CTX_new()) == NULL)
return(NULL);
new->inum=BN_new();
BN_mod_mul(new->num,a->num,a->num,a->mod,ctx);
BN_mod_mul(new->inum,a->inum,a->inum,a->mod,ctx);
BN_copy(new->mod,a->mod);
BN_BL_CTX_free(a);
return(new);
}
void BN_BL_CTX_free(a)
BN_BL_CTX *a;
{
int i;
if (a == NULL) return;
i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_RSA);
if (i > 0) return;
#ifdef REF_CHECK
if (i < 0)
{
fprintf(stderr,"BN_BL_CTX_free, bad reference count\n");
abort();
}
#endif
if (a->num == NULL) BN_clear_free(a->num);
if (a->inum == NULL) BN_clear_free(a->inum);
if (a->mod == NULL) BN_clear_free(a->mod);
}

97
crypto/bn/bn_mod.c
View file

@ -1,97 +0,0 @@
/* crypto/bn/bn_mod.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "cryptlib.h"
#include "bn_lcl.h"
/* rem != m */
int BN_mod(rem, m, d,ctx)
BIGNUM *rem;
BIGNUM *m;
BIGNUM *d;
BN_CTX *ctx;
{
#if 0 /* The old slow way */
int i,nm,nd;
BIGNUM *dv;
if (BN_ucmp(m,d) < 0)
return((BN_copy(rem,m) == NULL)?0:1);
dv=ctx->bn[ctx->tos];
if (!BN_copy(rem,m)) return(0);
nm=BN_num_bits(rem);
nd=BN_num_bits(d);
if (!BN_lshift(dv,d,nm-nd)) return(0);
for (i=nm-nd; i>=0; i--)
{
if (BN_cmp(rem,dv) >= 0)
{
if (!BN_sub(rem,rem,dv)) return(0);
}
if (!BN_rshift1(dv,dv)) return(0);
}
return(1);
#else
return(BN_div(NULL,rem,m,d,ctx));
#endif
}

180
crypto/bn/bn_sub.c
View file

@ -1,180 +0,0 @@
/* crypto/bn/bn_sub.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <stdio.h>
#include "cryptlib.h"
#include "bn_lcl.h"
/* unsigned subtraction of b from a, a must be larger than b. */
void bn_qsub(r, a, b)
BIGNUM *r;
BIGNUM *a;
BIGNUM *b;
{
int max,min;
register BN_ULONG t1,t2,*ap,*bp,*rp;
int i,carry;
#if defined(IRIX_CC_BUG) && !defined(LINT)
int dummy;
#endif
max=a->top;
min=b->top;
ap=a->d;
bp=b->d;
rp=r->d;
carry=0;
for (i=0; i<min; i++)
{
t1= *(ap++);
t2= *(bp++);
if (carry)
{
carry=(t1 <= t2);
t1=(t1-t2-1)&BN_MASK2;
}
else
{
carry=(t1 < t2);
t1=(t1-t2)&BN_MASK2;
}
#if defined(IRIX_CC_BUG) && !defined(LINT)
dummy=t1;
#endif
*(rp++)=t1&BN_MASK2;
}
if (carry) /* subtracted */
{
while (i < max)
{
i++;
t1= *(ap++);
t2=(t1-1)&BN_MASK2;
*(rp++)=t2;
if (t1 > t2) break;
}
}
#if 0
memcpy(rp,ap,sizeof(*rp)*(max-i));
#else
for (; i<max; i++)
*(rp++)= *(ap++);
#endif
r->top=max;
bn_fix_top(r);
}
int BN_sub(r, a, b)
BIGNUM *r;
BIGNUM *a;
BIGNUM *b;
{
int max,i;
int add=0,neg=0;
BIGNUM *tmp;
/* a - b a-b
* a - -b a+b
* -a - b -(a+b)
* -a - -b b-a
*/
if (a->neg)
{
if (b->neg)
{ tmp=a; a=b; b=tmp; }
else
{ add=1; neg=1; }
}
else
{
if (b->neg) { add=1; neg=0; }
}
if (add)
{
/* As a fast max size, do a a->top | b->top */
i=(a->top | b->top)+1;
if (bn_wexpand(r,i) == NULL)
return(0);
if (i)
bn_qadd(r,a,b);
else
bn_qadd(r,b,a);
r->neg=neg;
return(1);
}
/* We are actually doing a - b :-) */
max=(a->top > b->top)?a->top:b->top;
if (bn_wexpand(r,max) == NULL) return(0);
if (BN_ucmp(a,b) < 0)
{
bn_qsub(r,b,a);
r->neg=1;
}
else
{
bn_qsub(r,a,b);
r->neg=0;
}
return(1);
}

32
crypto/bn/m.pl
View file

@ -1,32 +0,0 @@
#!/usr/local/bin/perl
for ($i=0; $i<256; $i++)
{
for ($j=0; $j<256; $j++)
{
$a0=$i&0x0f;
$a1=($i>>4)&0x0f;
$b0=$j&0x0f;
$b1=($j>>4)&0x0f;
$a0b0=$a0*$b0;
$a1b1=$a1*$b1;
$a01=$a0-$a1;
$b10=$b1-$b0;
$a01b10=$a01*$b10;
if ($a01b10 < 0)
{
$neg=1;
$a01b10= -$a01b10;
}
$t=($a0b0>>4)+($a0b0&0x0f)+($a1b1&0x0f);
if ($neg)
{ $t-=($a01b10&0x0f); }
else { $t+=($a01b10&0x0f); }
printf("%02X %s%02X %02X\n",$a1b1,($neg)?"-":" ",$a01b10,$a0b0)
if ($t < 0)
}
}

378
crypto/bn/stuff/bn_knuth.c
View file

@ -1,378 +0,0 @@
/* crypto/bn/bn_knuth.c */
#include <stdio.h>
#include "cryptlib.h"
#include "bn.h"
/* This is just a test implementation, it has not been modified for
* speed and it still has memory leaks. */
int BN_mask_bits(BIGNUM *a,int n);
#undef DEBUG
#define MAIN
/* r must be different to a and b
* Toom-Cook multiplication algorithm, taken from
* The Art Of Computer Programming, Volume 2, Donald Knuth
*/
#define CODE1 ((BIGNUM *)0x01)
#define CODE2 ((BIGNUM *)0x02)
#define CODE3 ((BIGNUM *)0x03)
#define MAXK (30+1)
#define C3 3
#define C4 4
#define C5 5
#define C6 6
#define C7 7
#define C8 8
#define C9 9
#define C10 10
#define DONE 11
int new_total=0;
int Free_total=0;
int max=0,max_total=0;
BIGNUM *LBN_new(void );
BIGNUM *LBN_dup(BIGNUM *a);
void LBN_free(BIGNUM *a);
int BN_mul_knuth(w, a, b)
BIGNUM *w;
BIGNUM *a;
BIGNUM *b;
{
int ret=1;
int i,j,n,an,bn,y,z;
BIGNUM *U[MAXK],*V[MAXK],*T[MAXK];
BIGNUM *C[(MAXK*2*3)];
BIGNUM *W[(MAXK*2)],*t1,*t2,*t3,*t4;
int Utos,Vtos,Ctos,Wtos,Ttos;
unsigned int k,Q,R;
unsigned int q[MAXK];
unsigned int r[MAXK];
int state;
/* C1 */
Utos=Vtos=Ctos=Wtos=Ttos=0;
k=1;
q[0]=q[1]=64;
r[0]=r[1]=4;
Q=6;
R=2;
if (!bn_expand(w,BN_BITS2*2)) goto err;
an=BN_num_bits(a);
bn=BN_num_bits(b);
n=(an > bn)?an:bn;
while ((q[k-1]+q[k]) < n)
{
k++;
Q+=R;
i=R+1;
if ((i*i) <= Q) R=i;
q[k]=(1<<Q);
r[k]=(1<<R);
}
#ifdef DEBUG
printf("k =");
for (i=0; i<=k; i++) printf("%7d",i);
printf("\nq[k]=");
for (i=0; i<=k; i++) printf("%7d",q[i]);
printf("\nr[k]=");
for (i=0; i<=k; i++) printf("%7d",r[i]);
printf("\n");
#endif
/* C2 */
C[Ctos++]=CODE1;
if ((t1=LBN_dup(a)) == NULL) goto err;
C[Ctos++]=t1;
if ((t1=LBN_dup(b)) == NULL) goto err;
C[Ctos++]=t1;
state=C3;
for (;;)
{
#ifdef DEBUG
printf("state=C%d, Ctos=%d Wtos=%d\n",state,Ctos,Wtos);
#endif
switch (state)
{
int lr,lq,lp;
case C3:
k--;
if (k == 0)
{
t1=C[--Ctos];
t2=C[--Ctos];
#ifdef DEBUG
printf("Ctos=%d poped %d\n",Ctos,2);
#endif
if ((t2->top == 0) || (t1->top == 0))
w->top=0;
else
BN_mul(w,t1,t2);
LBN_free(t1); /* FREE */
LBN_free(t2); /* FREE */
state=C10;
}
else
{
lr=r[k];
lq=q[k];
lp=q[k-1]+q[k];
state=C4;
}
break;
case C4:
for (z=0; z<2; z++) /* do for u and v */
{
/* break the item at C[Ctos-1]
* into lr+1 parts of lq bits each
* for j=0; j<=2r; j++
*/
t1=C[--Ctos]; /* pop off u */
#ifdef DEBUG
printf("Ctos=%d poped %d\n",Ctos,1);
#endif
if ((t2=LBN_dup(t1)) == NULL) goto err;
BN_mask_bits(t2,lq);
T[Ttos++]=t2;
#ifdef DEBUG
printf("C4 r=0 bits=%d\n",BN_num_bits(t2));
#endif
for (i=1; i<=lr; i++)
{
if (!BN_rshift(t1,t1,lq)) goto err;
if ((t2=LBN_dup(t1)) == NULL) goto err;
BN_mask_bits(t2,lq);
T[Ttos++]=t2;
#ifdef DEBUG
printf("C4 r=%d bits=%d\n",i,
BN_num_bits(t2));
#endif
}
LBN_free(t1);
if ((t2=LBN_new()) == NULL) goto err;
if ((t3=LBN_new()) == NULL) goto err;
for (j=0; j<=2*lr; j++)
{
if ((t1=LBN_new()) == NULL) goto err;
if (!BN_set_word(t3,j)) goto err;
for (i=lr; i>=0; i--)
{
if (!BN_mul(t2,t1,t3)) goto err;
if (!BN_add(t1,t2,T[i])) goto err;
}
/* t1 is U(j) */
if (z == 0)
U[Utos++]=t1;
else
V[Vtos++]=t1;
}
LBN_free(t2);
LBN_free(t3);
while (Ttos) LBN_free(T[--Ttos]);
}
#ifdef DEBUG
for (i=0; i<Utos; i++)
printf("U[%2d]=%4d bits\n",i,BN_num_bits(U[i]));
for (i=0; i<Vtos; i++)
printf("V[%2d]=%4d bits\n",i,BN_num_bits(V[i]));
#endif
/* C5 */
#ifdef DEBUG
printf("PUSH CODE2 and %d CODE3 onto stack\n",2*lr);
#endif
C[Ctos++]=CODE2;
for (i=2*lr; i>0; i--)
{
C[Ctos++]=V[i];
C[Ctos++]=U[i];
C[Ctos++]=CODE3;
}
C[Ctos++]=V[0];
C[Ctos++]=U[0];
#ifdef DEBUG
printf("Ctos=%d pushed %d\n",Ctos,2*lr*3+3);
#endif
Vtos=Utos=0;
state=C3;
break;
case C6:
if ((t1=LBN_dup(w)) == NULL) goto err;
W[Wtos++]=t1;
#ifdef DEBUG
printf("put %d bit number onto w\n",BN_num_bits(t1));
#endif
state=C3;
break;
case C7:
lr=r[k];
lq=q[k];
lp=q[k]+q[k-1];
z=Wtos-2*lr-1;
for (j=1; j<=2*lr; j++)
{
for (i=2*lr; i>=j; i--)
{
if (!BN_sub(W[z+i],W[z+i],W[z+i-1])) goto err;
BN_div_word(W[z+i],j);
}
}
state=C8;
break;
case C8:
y=2*lr-1;
if ((t1=LBN_new()) == NULL) goto err;
if ((t3=LBN_new()) == NULL) goto err;
for (j=y; j>0; j--)
{
if (!BN_set_word(t3,j)) goto err;
for (i=j; i<=y; i++)
{
if (!BN_mul(t1,W[z+i+1],t3)) goto err;
if (!BN_sub(W[z+i],W[z+i],t1)) goto err;
}
}
LBN_free(t1);
LBN_free(t3);
state=C9;
break;
case C9:
BN_zero(w);
#ifdef DEBUG
printf("lq=%d\n",lq);
#endif
for (i=lr*2; i>=0; i--)
{
BN_lshift(w,w,lq);
BN_add(w,w,W[z+i]);
}
for (i=0; i<=lr*2; i++)
LBN_free(W[--Wtos]);
state=C10;
break;
case C10:
k++;
t1=C[--Ctos];
#ifdef DEBUG
printf("Ctos=%d poped %d\n",Ctos,1);
printf("code= CODE%d\n",t1);
#endif
if (t1 == CODE3)
state=C6;
else if (t1 == CODE2)
{
if ((t2=LBN_dup(w)) == NULL) goto err;
W[Wtos++]=t2;
state=C7;
}
else if (t1 == CODE1)
{
state=DONE;
}
else
{
printf("BAD ERROR\n");
goto err;
}
break;
default:
printf("bad state\n");
goto err;
break;
}
if (state == DONE) break;
}
ret=1;
err:
if (ret == 0) printf("ERROR\n");
return(ret);
}
#ifdef MAIN
main()
{
BIGNUM *a,*b,*r;
int i;
if ((a=LBN_new()) == NULL) goto err;
if ((b=LBN_new()) == NULL) goto err;
if ((r=LBN_new()) == NULL) goto err;
if (!BN_rand(a,1024*2,0,0)) goto err;
if (!BN_rand(b,1024*2,0,0)) goto err;
for (i=0; i<10; i++)
{
if (!BN_mul_knuth(r,a,b)) goto err; /**/
/*if (!BN_mul(r,a,b)) goto err; /**/
}
BN_print(stdout,a); printf(" * ");
BN_print(stdout,b); printf(" =\n");
BN_print(stdout,r); printf("\n");
printf("BN_new() =%d\nBN_free()=%d max=%d\n",new_total,Free_total,max);
exit(0);
err:
ERR_load_crypto_strings();
ERR_print_errors(stderr);
exit(1);
}
#endif
int BN_mask_bits(a,n)
BIGNUM *a;
int n;
{
int b,w;
w=n/BN_BITS2;
b=n%BN_BITS2;
if (w >= a->top) return(0);
if (b == 0)
a->top=w;
else
{
a->top=w+1;
a->d[w]&= ~(BN_MASK2<<b);
}
return(1);
}
BIGNUM *LBN_dup(a)
BIGNUM *a;
{
new_total++;
max_total++;
if (max_total > max) max=max_total;
return(BN_dup(a));
}
BIGNUM *LBN_new()
{
new_total++;
max_total++;
if (max_total > max) max=max_total;
return(BN_new());
}
void LBN_free(a)
BIGNUM *a;
{
max_total--;
if (max_total > max) max=max_total;
Free_total++;
BN_free(a);
}

340
crypto/bn/stuff/div.c
View file

@ -1,340 +0,0 @@
/* crypto/bn/div.c */
#include <stdio.h>
#include "cryptlib.h"
#include "bn.h"
BN_ULONG bn_div_2word();
int BN_div2(dv, rm, num, div,ctx)
BIGNUM *dv;
BIGNUM *rm;
BIGNUM *num;
BIGNUM *div;
BN_CTX *ctx;
{
int norm_shift,i,j,nm,nd,loop;
BIGNUM *tmp,wnum,*snum,*sdiv,*res;
BN_ULONG *resp,*wnump;
BN_ULONG d0,d1;
int num_n,div_n;
#ifdef DEBUG
BN_print(stdout,num); printf(" number\n");
BN_print(stdout,div); printf(" divisor\n");
#endif
if (BN_is_zero(num))
{
BNerr(BN_F_BN_DIV,BN_R_DIV_BY_ZERO);
return(0);
}
if (BN_cmp(num,div) < 0)
{
if (rm != NULL)
{ if (BN_copy(rm,num) == NULL) return(0); }
if (dv != NULL) BN_zero(dv);
return(1);
}
tmp=ctx->bn[ctx->tos];
snum=ctx->bn[ctx->tos+1];
sdiv=ctx->bn[ctx->tos+2];
if (dv == NULL)
res=ctx->bn[ctx->tos+3];
else res=dv;
/* First we normalise the numbers */
norm_shift=BN_BITS2-((BN_num_bits(div))%BN_BITS2);
BN_lshift(sdiv,div,norm_shift);
norm_shift+=BN_BITS2;
BN_lshift(snum,num,norm_shift);
div_n=sdiv->top;
num_n=snum->top;
loop=num_n-div_n;
#ifdef DEBUG
BN_print(stdout,snum); printf(" shifted num, forget last word\n");
BN_print(stdout,sdiv); printf(" shifted div\n");
#endif
/* Lets setup a 'win'dow into snum
* This is the part that corresponds to the current
* 'area' being divided */
wnum.d= &(snum->d[loop]);
wnum.top= div_n;
wnum.max= snum->max; /* a bit of a lie */
wnum.neg= 0;
/* Get the top 2 words of sdiv */
i=sdiv->top;
d0=sdiv->d[div_n-1];
d1=sdiv->d[div_n-2];
/* pointer to the 'top' of snum */
wnump= &(snum->d[num_n-1]);
/* Setup to 'res' */
res->neg=0;
res->top=loop;
resp= &(res->d[loop-1]);
bn_expand(res,(loop+1)*BN_BITS2);
/* space for temp */
bn_expand(tmp,(div_n+1)*BN_BITS2);
#ifdef DEBUG
printf("wnum="); BN_print(stdout,&wnum); printf(" initial sub check\n");
printf("div ="); BN_print(stdout,sdiv); printf(" loop=%d\n",loop);
#endif
if (BN_cmp(&wnum,sdiv) >= 0)
{
BN_sub(&wnum,&wnum,sdiv);
*resp=1;
res->d[res->top-1]=1;
}
else
res->top--;
resp--;
#ifdef DEBUG
BN_print(stdout,res); printf(" initial result\n");
BN_print(stdout,&wnum); printf(" wnum\n");
#endif
for (i=0; i<loop-1; i++)
{
BN_ULONG q,n0;
BN_ULLONG t1,t2,t3;
BN_ULONG l0;
wnum.d--;
wnum.top++;
#ifdef DEBUG
BN_print(stderr,&wnum); printf(" to divide\n");
#endif
q=0;
n0=wnump[0];
t1=((BN_ULLONG)n0<<BN_BITS2)|wnump[-1];
if (n0 == d0)
q=BN_MASK2;
else
{
t2=(t1/d0);
q=(t2&BN_MASK2);
#ifdef DEBUG
printf("t1=%08X / d0=%08X = %X (%X)\n",t1,d0,q,t2);
#endif
}
for (;;)
{
t2=(BN_ULLONG)d1*q;
t3=t1-(BN_ULLONG)q*d0;
#ifdef DEBUG
printf("d1*q= %X n01-q*d0 = %X\n",t2,t3);
#endif
if ((t3>>BN_BITS2) ||
(t2 <= ((t3<<BN_BITS2)+wnump[-2])))
break;
#ifdef DEBUG
printf("reduce q\n");
#endif
q--;
}
l0=bn_mul_word(tmp->d,sdiv->d,div_n,q);
if (l0)
tmp->d[div_n]=l0;
else
tmp->d[div_n]=0;
for (j=div_n+1; j>0; j--)
if (tmp->d[j-1]) break;
tmp->top=j;
#ifdef DEBUG
printf("q=%08X\n",q);
BN_print(stdout,&wnum); printf(" number\n");
BN_print(stdout,tmp); printf(" subtract\n");
BN_print(stdout,snum); printf(" shifted number before\n");
BN_print(stdout,&wnum); printf(" wnum before\n");
#endif
j=wnum.top;
BN_sub(&wnum,&wnum,tmp);
snum->top=snum->top+wnum.top-j;
#ifdef DEBUG
BN_print(stdout,&wnum); printf(" wnum after\n");
BN_print(stdout,snum); printf(" shifted number after\n");
#endif
if (wnum.neg)
{
q--;
j=wnum.top;
BN_add(&wnum,&wnum,sdiv);
snum->top+=wnum.top-j;
fprintf(stderr,"addback\n");
#ifdef DEBUG
BN_print(stdout,snum); printf("after addback************************:\n");
#endif
}
*(resp--)=q;
#ifdef DEBUG
BN_print(stdout,res); printf(" result\n");
#endif
wnump--;
}
if (rm != NULL)
BN_rshift(rm,snum,norm_shift);
return(1);
}
main()
{
BIGNUM *a,*b,*c,*d;
BIGNUM *cc,*dd;
BN_CTX *ctx;
int i,x;
a=BN_new();
b=BN_new();
c=BN_new();
d=BN_new();
cc=BN_new();
dd=BN_new();
ctx=BN_CTX_new();
for (i=0; i<10240; i++)
{
BN_rand(a,80,0,0);
BN_rand(b,60,0,0);
BN_div2(d,c,a,b,ctx);
BN_div(dd,cc,a,b,ctx);
if ((BN_cmp(d,dd) != 0) || (BN_cmp(c,cc) != 0))
{
BN_print(stderr,a); fprintf(stderr," / ");
BN_print(stderr,b); fprintf(stderr," d=");
BN_print(stderr,d); fprintf(stderr," r= ");
BN_print(stderr,c); fprintf(stderr,"\nd=");
BN_print(stderr,dd); fprintf(stderr," r= ");
BN_print(stderr,cc); fprintf(stderr,"\n");
}
}
#ifdef undef
/*
BN_rand(a,600,0,0);
BN_rand(b,400,0,0);
for (i=0; i<2000000; i++)
{
BN_div2(d,c,a,b,ctx);
}
*/
/* for (i=0;;) */
/* for (i=0; i<0xffffffff; i++)
{
BN_ULONG rr,r,a,b,c;
BN_ULLONG l;
a=rand()&BN_MASK2;
b=rand()&BN_MASK2;
for (;;)
{
c=rand()&BN_MASK2;
if (c) break;
}
/* for (x=1; x<256*256; x++) */
{
c=x;
a=i>>8;
b=i&0xff;
a&= ~(0xFFFFFF<<(BN_num_bits_word(c)));
r=bn_div_2word(a,b,c);
rr=(BN_ULONG)((((BN_ULLONG)a<<BN_BITS2)|b)/c);
if ((i & 0xfffff) == 0) fprintf(stderr,"%d\n",i,r,rr);
/*if (x == 255)
fprintf(stderr,"%6d/%3d = %4d %4d\n",(a<<8)|b,c,r,rr); */
if (rr != r)
{
fprintf(stderr,"%8d %02X%02X / %02X = %02X %02X\n",
i,a,b,c,rr,r);
abort();
}
}
}
#endif
}
/* Divide h-l by d and return the result. */
BN_ULONG bn_div_2word(l,h,d)
BN_ULONG l,h,d;
{
BN_ULONG dh,dl,q,ret=0,th,tl,t,top;
int i,count=2;
if (d == 0) return(-1);
i=BN_num_bits_word(d);
if ((i != BN_BITS2) && (h > 1<<i))
{
fprintf(stderr,"Division would overflow\n");
abort();
}
i=BN_BITS2-i;
if (h >= d) h-=d;
if (i)
{
d<<=i;
h=(h<<i)|(l>>(BN_BITS2-i));
l<<=i;
}
dh=(d&BN_MASK2h)>>BN_BITS4;
dl=(d&BN_MASK2l);
for (;;)
{
if ((h>>BN_BITS4) == dh)
q=BN_MASK2l;
else
q=h/dh;
for (;;)
{
t=(h-q*dh);
if ((t&BN_MASK2h) ||
((dl*q) <= (
(t<<BN_BITS4)+
((l&BN_MASK2h)>>BN_BITS4))))
break;
q--;
}
th=q*dh;
tl=q*dl;
t=(tl>>BN_BITS4);
tl=(tl<<BN_BITS4)&BN_MASK2h;
th+=t;
if (l < tl) th++;
l-=tl;
if (h < th)
{
fprintf(stderr,"add back\n");
h+=d;
q--;
}
h-=th;
if (--count == 0) break;
ret=q<<BN_BITS4;
h=((h<<BN_BITS4)|(l>>BN_BITS4))&BN_MASK2;
l=(l&BN_MASK2l)<<BN_BITS4;
}
ret|=q;
return(ret);
}

17
crypto/bn/stuff/mont.doc
View file

@ -1,17 +0,0 @@
All numbers (a) are stored aR mod N (except abRR)
RR = REDC(R*R) /* RR mod N */
convert a -> aR
convert b -> bR
{
abRR = aR * bR
abR = REDC(abRR); /* mod N */
}
ab = REDC(abR); /* mod N */
REDC strips off a multiplicaion by R mod N

410
crypto/bn/stuff/wei_mulw.c
View file

@ -1,410 +0,0 @@
/* crypto/bn/wei_mulw.c */
#include <stdio.h>
#include "cryptlib.h"
#include "bn.h"
#include "bn_lcl.h"
BN_ULONG bn_add_word(BN_ULONG *a,BN_ULONG c,int num);
BN_ULONG bn_add_words(BN_ULONG *ret,BN_ULONG *a,BN_ULONG *b,int num);
BN_ULONG bn_sub_words(BN_ULONG *ret,BN_ULONG *a,BN_ULONG *b,int num);
void BN_mul_4words(BN_ULONG *ret,BN_ULONG a0,BN_ULONG a1,
BN_ULONG b0,BN_ULONG b1);
void pr(a,n,s)
BN_ULONG *a;
int n;
{
while (n--)
fprintf(stdout,"%02X",a[n]);
fprintf(stdout,"%s",s);
}
BN_ULONG bn_add_word(a,w,num)
BN_ULONG *a;
BN_ULONG w;
int num;
{
BN_ULONG t;
#ifdef DEBUG
{ BN_ULONG *aa=a; int i; for (i=num; i>0; i--) fprintf(stdout,"%02X",aa[i-1]);
fprintf(stdout," + %X - ",w); i=num;
#endif
loop:
t= *a;
t=(t+w)&BN_MASK2;
*(a++)=t;
w=(t < w);
if (w && --num) goto loop;
#ifdef DEBUG
for (; i>0; i--) fprintf(stdout,"%02X",aa[i-1]);
fprintf(stdout,"\n");
}
#endif
return(w);
}
BN_ULONG bn_add_words(r,a,b,num)
BN_ULONG *r;
BN_ULONG *a;
BN_ULONG *b;
int num;
{
#if defined(BN_LLONG)
BN_ULLONG t;
BN_ULONG c=0;
int i;
if (num&1) abort();
for (i=0; i<num; i+=2)
{
t=(BN_ULLONG)a[i]+b[i]+c;
r[i+0]=L(t);
t=(BN_ULLONG) H(t)+a[i+1]+b[i+1];
r[i+1]=L(t);
c=H(t);
}
return(c);
#else
BN_ULONG c=0,t1,t2;
for ( ; num; num--)
{
t1= *(a++);
t2= *(b++);
if (c)
{
c=(t2 >= ((~t1)&BN_MASK2));
(*r++)=(t1+t2+1)&BN_MASK2;
}
else
{
t2=(t1+t2)&BN_MASK2;
c=(t2 < t1);
(*r++)=t2;
}
}
return(c);
#endif
}
BN_ULONG bn_sub_words(r,a,b,num)
BN_ULONG *r;
BN_ULONG *a;
BN_ULONG *b;
int num;
{
#if defined(BN_LLONG)
BN_ULLONG t;
BN_ULONG c=0;
int i;
if (num&1) abort();
for (i=0; i<num; i+=2)
{
t=(BN_ULLONG)a[i]-b[i]-c;
r[i+0]=L(t);
t=(BN_ULLONG)a[i+1]-b[i+1]-(0-H(t))&BN_MASK2;
r[i+1]=L(t);
c=H(t);
}
return(c);
#else
BN_ULONG c=0,t1,t2;
for ( ; num; num--)
{
t1= *(a++);
t2= *(b++);
if (c)
{
c=(t1 <= t2);
t1=(t1-t2-1);
}
else
{
c=(t1 < t2);
t1=(t1-t2);
}
(*r++)=t1&BN_MASK2;
}
return(c);
#endif
}
/* ret[3,2,1,0] = a1,a0 * b1,b0 */
void BN_mul_4words(ret,a0,a1,b0,b1)
BN_ULONG *ret;
BN_ULONG a0,a1,b0,b1;
{
BN_ULONG s,u;
BN_ULLONG fix,a0b0,a1b1,tmp;
if (a1 >= a0)
{
s=(a1-a0);
u=(b0-b1);
fix=(BN_ULLONG)s*u;
if (b0 >= b1) s=0;
}
else
{
BN_ULONG u;
if (b0 > b1)
{
s=(b0-b1);
u=(a1-a0);
fix=(BN_ULLONG)s*u;
}
else
{
u=(a0-a1);
s=(b1-b0);
fix=(BN_ULLONG)s*u;
s=0;
}
}
a0b0=(BN_ULLONG)a0*b0;
ret[0]=L(a0b0);
a1b1=(BN_ULLONG)a1*b1;
tmp=(BN_ULLONG) H(a0b0) + L(a0b0) + L(fix) + L(a1b1);
ret[1]=L(tmp);
tmp=(BN_ULLONG) a1b1 + H(tmp) + H(a0b0) + H(fix) + H(a1b1) - s;
ret[2]=L(tmp);
ret[3]=H(tmp);
}
/* ret[3,2,1,0] += a1,a0 * b1,b0 */
BN_ULONG BN_mul_add_4words(ret,a0,a1,b0,b1)
BN_ULONG *ret;
BN_ULONG a0,a1,b0,b1;
{
BN_ULONG s,u;
BN_ULLONG fix,a0b0,a1b1,tmp;
#ifdef DEBUG
fprintf(stdout,"%02X%02X%02X%02X",ret[3],ret[2],ret[1],ret[0]);
fprintf(stdout," + ( %02X%02X * %02X%02X ) - ",a1,a0,b1,b0);
#endif
if (a1 >= a0)
{
s=(a1-a0);
u=(b0-b1);
fix=(BN_ULLONG)s*u;
if (b0 >= b1) s=0;
}
else
{
if (b0 > b1)
{
s=(b0-b1);
u=(a1-a0);
fix=(BN_ULLONG)s*u;
}
else
{
u=(a0-a1);
s=(b1-b0);
fix=(BN_ULLONG)s*u;
s=0;
}
}
a0b0=(BN_ULLONG)a0*b0;
tmp=a0b0+ret[0];
ret[0]=L(tmp);
a1b1=(BN_ULLONG)a1*b1;
tmp=(BN_ULLONG) H(tmp) + L(a0b0) + L(fix) + L(a1b1) + ret[1];
ret[1]=L(tmp);
tmp=(BN_ULLONG) H(tmp) + L(a1b1) + H(a0b0) +
H(fix) + H(a1b1) -s + ret[2];
ret[2]=L(tmp);
tmp=(BN_ULLONG) H(tmp) + H(a1b1) + ret[3];
ret[3]=L(tmp);
#ifdef DEBUG
fprintf(stdout,"%02X%02X%02X%02X%02X\n",H(tmp),ret[3],ret[2],ret[1],ret[0]);
#endif
return(H(tmp));
}
/* ret[3,2,1,0] += a1,a0 * a1,a0 */
void BN_sqr_4words(ret,a0,a1)
BN_ULONG *ret;
BN_ULONG a0,a1;
{
BN_ULONG s,u;
BN_ULLONG tmp,tmp2;
tmp=(BN_ULLONG)a0*a0;
ret[0]=L(tmp);
tmp2=(BN_ULLONG)a0*a1;
tmp=(BN_ULLONG)H(tmp)+L(tmp2)*2;
ret[1]=L(tmp);
tmp=(BN_ULLONG)a1*a1+H(tmp)+H(tmp2)*2;
ret[2]=L(tmp);
ret[3]=L(tmp);
}
#define N0 (0)
#define N1 (half)
#define N2 (num)
#define N3 (num+half)
#define word_cmp(r,a,b,num) \
{ \
int n=num; \
\
(r)=0; \
while (n--) \
{ \
if ((a)[(n)] > (b)[(n)]) \
{ (r)=1; break; } \
else if ((a)[(n)] < (b)[(n)]) \
{ (r)= -1; break; } \
} \
}
/* (a->top == b->top) && (a->top >= 2) && !(a->top & 1) */
void bn_recursize_mul(r,t,a,b,num)
BN_ULONG *r,*t,*a,*b;
int num;
{
if ((num < 2) || (num&1))
abort();
/* fprintf(stderr,"num=%d half=%d\n",num,num/2);*/
if (num == 2)
BN_mul_4words(r,a[0],a[1],b[0],b[1]);
else if (num == 4)
{
BN_ULONG c,tmp;
BN_mul_4words(&(r[0]),a[0],a[1],b[0],b[1]);
BN_mul_4words(&(r[4]),a[2],a[3],b[2],b[3]);
c =BN_mul_add_4words(&(r[2]),a[0],a[1],b[2],b[3]);
c+=BN_mul_add_4words(&(r[2]),a[2],a[3],b[0],b[1]);
bn_add_word(&(r[6]),c,2);
}
else
{
int half=num/2;
int carry,cmp_a,cmp_b;
word_cmp(cmp_a,&(a[0]),&(a[half]),half);
word_cmp(cmp_b,&(b[0]),&(b[half]),half);
switch (cmp_a*2+cmp_a+cmp_b)
{
case -4:
bn_sub_words(&(t[N0]),&(a[N1]),&(a[N0]),half);
bn_sub_words(&(t[N1]),&(b[N0]),&(b[N1]),half);
bn_recursize_mul(&(r[N1]),&(t[N2]),
&(t[N0]),&(t[N1]),half);
bn_sub_words(&(r[N2]),&(r[N2]),&(t[N0]),half);
carry= -1;
break;
case -2:
bn_sub_words(&(t[N0]),&(a[N1]),&(a[N0]),half);
bn_sub_words(&(t[N1]),&(b[N0]),&(b[N1]),half);
bn_recursize_mul(&(r[N1]),&(t[N2]),
&(t[N0]),&(t[N1]),half);
carry=0;
break;
case 2:
bn_sub_words(&(t[N0]),&(a[N0]),&(a[N1]),half);
bn_sub_words(&(t[N1]),&(b[N1]),&(b[N0]),half);
bn_recursize_mul(&(r[N1]),&(t[N2]),
&(t[N0]),&(t[N1]),half);
carry=0;
break;
case 4:
bn_sub_words(&(t[N0]),&(a[N1]),&(a[N0]),half);
bn_sub_words(&(t[N1]),&(b[N0]),&(b[N1]),half);
bn_recursize_mul(&(r[N1]),&(t[N2]),
&(t[N0]),&(t[N1]),half);
bn_sub_words(&(r[N2]),&(r[N2]),&(t[N1]),half);
carry= -1;
break;
default:
memset(&(r[N1]),0,sizeof(BN_ULONG)*num);
break;
}
bn_recursize_mul(&(t[N0]),&(t[N2]),&(a[N0]),&(b[N0]),half);
#ifdef DEBUG
pr(a,half," * ");
pr(b,half," - ");
pr(t,num," - 0\n");
#endif
memcpy(&(r[N0]),&(t[N0]),half*sizeof(BN_ULONG));
if (bn_add_words(&(r[N1]),&(r[N1]),&(t[N1]),half))
{ bn_add_word(&(t[N1]),1,half); }
carry+=bn_add_words(&(r[N1]),&(r[N1]),&(t[N0]),num);
bn_recursize_mul(&(t[N0]),&(t[N2]),&(a[N1]),&(b[N1]),half);
carry+=bn_add_words(&(r[N1]),&(r[N1]),&(t[N0]),num);
carry+=bn_add_words(&(r[N2]),&(r[N2]),&(t[N0]),half);
memcpy(&(r[N3]),&(t[N1]),half*sizeof(BN_ULONG));
bn_add_word(&(r[N3]),carry,half);
}
}
main()
{
BIGNUM *a,*b,*r,*t;
int i,j;
a=BN_new();
b=BN_new();
r=BN_new();
t=BN_new();
#define BITS 1024
bn_expand(r,BITS*2);
bn_expand(t,BITS*2);
fprintf(stdout,"obase=16\n");
fprintf(stdout,"ibase=16\n");
for (i=0; i<10; i++)
{
BN_rand(a,BITS,0,0);
BN_rand(b,BITS,0,0);
r->top=(BITS*2)/BN_BITS2;
memset(r->d,0,sizeof(r->top)*sizeof(BN_ULONG));
memset(t->d,0,sizeof(r->top)*sizeof(BN_ULONG));
for (j=0; j<1000; j++)
{
/* BN_mul(r,a,b); /**/
bn_recursize_mul(r->d,t->d,a->d,b->d,a->top); /**/
}
BN_print(stdout,a); fprintf(stdout," * ");
BN_print(stdout,b); fprintf(stdout," - ");
BN_print(stdout,r); fprintf(stdout,"\n");
}
}

18
crypto/pkcs7/mf.p7
View file

@ -1,18 +0,0 @@
-----BEGIN PKCS7-----
MIAGCSqGSIb3DQEHAqCAMIIC2QIBATEMMAoGCCqGSIb3DQIFMIAGCSqGSIb3DQEH
AQAAoIIB7TCCAekwggFSAgEAMA0GCSqGSIb3DQEBBAUAMFsxCzAJBgNVBAYTAkFV
MRMwEQYDVQQIEwpRdWVlbnNsYW5kMRowGAYDVQQKExFDcnlwdFNvZnQgUHR5IEx0
ZDEbMBkGA1UEAxMSVGVzdCBDQSAoMTAyNCBiaXQpMB4XDTk3MDYwOTEzNTc0NloX
DTk4MDYwOTEzNTc0NlowYzELMAkGA1UEBhMCQVUxEzARBgNVBAgTClF1ZWVuc2xh
bmQxGjAYBgNVBAoTEUNyeXB0U29mdCBQdHkgTHRkMSMwIQYDVQQDExpTZXJ2ZXIg
dGVzdCBjZXJ0ICg1MTIgYml0KTBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCfs8OE
J5X/EjFSDxXvRhHErYDmNlsP3YDXYY3g/HJFCTT+VWZFQ0xol2r+qKCl3194/+7X
ZLg/BMtv/yr+/rntAgMBAAEwDQYJKoZIhvcNAQEEBQADgYEAeEzEdgr2nChPcALL
vY8gl/GIlpoAjPmKD+pLeGZI9s+SEX5u1q8nCrJ6ZzkfrRnqgI5Anmev9+qPZfdU
bz5zdVSf4sUL9nX9ChXjK9NCJA3UzQHSFqhZErGUwGNkAHYHp2+zAdY6Ho6rmMzt
g0CDu/sKR4qzm6REsQGS8kgpjz4xgcUwgcICAQEwYDBbMQswCQYDVQQGEwJBVTET
MBEGA1UECBMKUXVlZW5zbGFuZDEaMBgGA1UEChMRQ3J5cHRTb2Z0IFB0eSBMdGQx
GzAZBgNVBAMTElRlc3QgQ0EgKDEwMjQgYml0KQIBADAKBggqhkiG9w0CBTANBgkq
hkiG9w0BAQQFAARALnrxJiOX9XZf2D+3vL8SKMQmMq55LltomwOLGUru/q1uVXzi
ARg7FSCegOpA1nunsTURMUGgrPXKK4XmL4IseQAAAAA=
-----END PKCS7-----

33
crypto/pkcs7/p7.tst
View file

@ -1,33 +0,0 @@
-----BEGIN PKCS7-----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-----END PKCS7-----

195
crypto/rc4/rc4_enc.org
View file

@ -1,195 +0,0 @@
/* crypto/rc4/rc4_enc.org */
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
/* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
*
* Always modify rc4_enc.org since rc4_enc.c is automatically generated from
* it during SSLeay configuration.
* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
*/
#include "rc4.h"
/* if this is defined data[i] is used instead of *data, this is a %20
* speedup on x86 */
#define RC4_INDEX
char *RC4_version="RC4 part of SSLeay 0.8.1b 29-Jun-1998";
char *RC4_options()
{
#ifdef RC4_INDEX
if (sizeof(RC4_INT) == 1)
return("rc4(idx,char)");
else
return("rc4(idx,int)");
#else
if (sizeof(RC4_INT) == 1)
return("rc4(ptr,char)");
else
return("rc4(ptr,int)");
#endif
}
/* RC4 as implemented from a posting from
* Newsgroups: sci.crypt
* From: sterndark@netcom.com (David Sterndark)
* Subject: RC4 Algorithm revealed.
* Message-ID: <sternCvKL4B.Hyy@netcom.com>
* Date: Wed, 14 Sep 1994 06:35:31 GMT
*/
void RC4_set_key(key, len, data)
RC4_KEY *key;
int len;
register unsigned char *data;
{
register RC4_INT tmp;
register int id1,id2;
register RC4_INT *d;
unsigned int i;
d= &(key->data[0]);
for (i=0; i<256; i++)
d[i]=i;
key->x = 0;
key->y = 0;
id1=id2=0;
#define SK_LOOP(n) { \
tmp=d[(n)]; \
id2 = (data[id1] + tmp + id2) & 0xff; \
if (++id1 == len) id1=0; \
d[(n)]=d[id2]; \
d[id2]=tmp; }
for (i=0; i < 256; i+=4)
{
SK_LOOP(i+0);
SK_LOOP(i+1);
SK_LOOP(i+2);
SK_LOOP(i+3);
}
}
void RC4(key, len, indata, outdata)
RC4_KEY *key;
unsigned long len;
unsigned char *indata;
unsigned char *outdata;
{
register RC4_INT *d;
register RC4_INT x,y,tx,ty;
int i;
x=key->x;
y=key->y;
d=key->data;
#define LOOP(in,out) \
x=((x+1)&0xff); \
tx=d[x]; \
y=(tx+y)&0xff; \
d[x]=ty=d[y]; \
d[y]=tx; \
(out) = d[(tx+ty)&0xff]^ (in);
#ifndef RC4_INDEX
#define RC4_LOOP(a,b,i) LOOP(*((a)++),*((b)++))
#else
#define RC4_LOOP(a,b,i) LOOP(a[i],b[i])
#endif
i= -(int)len;
i=(int)(len>>3L);
if (i)
{
for (;;)
{
RC4_LOOP(indata,outdata,0);
RC4_LOOP(indata,outdata,1);
RC4_LOOP(indata,outdata,2);
RC4_LOOP(indata,outdata,3);
RC4_LOOP(indata,outdata,4);
RC4_LOOP(indata,outdata,5);
RC4_LOOP(indata,outdata,6);
RC4_LOOP(indata,outdata,7);
#ifdef RC4_INDEX
indata+=8;
outdata+=8;
#endif
if (--i == 0) break;
}
}
i=(int)len&0x07;
if (i)
{
for (;;)
{
RC4_LOOP(indata,outdata,0); if (--i == 0) break;
RC4_LOOP(indata,outdata,1); if (--i == 0) break;
RC4_LOOP(indata,outdata,2); if (--i == 0) break;
RC4_LOOP(indata,outdata,3); if (--i == 0) break;
RC4_LOOP(indata,outdata,4); if (--i == 0) break;
RC4_LOOP(indata,outdata,5); if (--i == 0) break;
RC4_LOOP(indata,outdata,6); if (--i == 0) break;
}
}
key->x=x;
key->y=y;
}