wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-21 07:47:32 +09:00
Code Issues Projects Releases Packages Wiki Activity

Update NSS to 3.32.1-RTM

Browse source
This commit is contained in:
wolfbeast 2018-02-06 11:46:26 +01:00 • committed by Roy Tam
commit c91ef9012b
512 changed files with 83203 additions and 16839 deletions
Download patch file Download diff file Expand all files Collapse all files

244
security/nss/lib/freebl/mpi/Makefile
View file

@ -1,244 +0,0 @@
#
# Makefile for MPI library
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
## Define CC to be the C compiler you wish to use. The GNU cc
## compiler (gcc) should work, at the very least
#CC=cc
#CC=gcc
##
## Define PERL to point to your local Perl interpreter. It
## should be Perl 5.x, although it's conceivable that Perl 4
## might work ... I haven't tested it.
##
#PERL=/usr/bin/perl
#PERL=perl
include target.mk
CFLAGS+= $(XCFLAGS)
##
## Define LIBS to include any libraries you need to link against.
## If NO_TABLE is define, LIBS should include '-lm' or whatever is
## necessary to bring in the math library. Otherwise, it can be
## left alone, unless your system has other peculiar requirements.
##
LIBS=#-lmalloc#-lefence#-lm
##
## Define RANLIB to be the library header randomizer; you might not
## need this on some systems (just set it to 'echo' on these systems,
## such as IRIX)
##
RANLIB=echo
##
## This is the version string used for the documentation and
## building the distribution tarball. Don't mess with it unless
## you are releasing a new version
VERS=1.7p6
## ----------------------------------------------------------------------
## You probably don't need to change anything below this line...
##
##
## This is the list of source files that need to be packed into
## the distribution file
SRCS= mpi.c mpprime.c mplogic.c mp_gf2m.c mpmontg.c mpi-test.c primes.c \
mpcpucache.c tests/ \
utils/gcd.c utils/invmod.c utils/lap.c \
utils/ptab.pl utils/sieve.c utils/isprime.c\
utils/dec2hex.c utils/hex2dec.c utils/bbs_rand.c \
utils/bbsrand.c utils/prng.c utils/primegen.c \
utils/basecvt.c utils/makeprime.c\
utils/fact.c utils/exptmod.c utils/pi.c utils/metime.c \
utils/mpi.h utils/mpprime.h mulsqr.c \
make-test-arrays test-arrays.txt all-tests make-logtab \
types.pl stats timetest multest
## These are the header files that go into the distribution file
HDRS=mpi.h mpi-config.h utils/mpi.h utils/mpi-config.h mpprime.h mplogic.h mp_gf2m.h \
mp_gf2m-priv.h utils/bbs_rand.h tests/mpi.h tests/mpprime.h
## These are the documentation files that go into the distribution file
DOCS=README doc utils/README utils/PRIMES
## This is the list of tools built by 'make tools'
TOOLS=gcd invmod isprime lap dec2hex hex2dec primegen prng \
basecvt fact exptmod pi makeprime identest
LIBOBJS = mpprime.o mpmontg.o mplogic.o mp_gf2m.o mpi.o mpcpucache.o $(AS_OBJS)
LIBHDRS = mpi-config.h mpi-priv.h mpi.h
APPHDRS = mpi-config.h mpi.h mplogic.h mp_gf2m.h mpprime.h
help:
@ echo ""
@ echo "The following targets can be built with this Makefile:"
@ echo ""
@ echo "libmpi.a - arithmetic and prime testing library"
@ echo "mpi-test - test driver (requires MP_IOFUNC)"
@ echo "tools - command line tools"
@ echo "doc - manual pages for tools"
@ echo "clean - clean up objects and such"
@ echo "distclean - get ready for distribution"
@ echo "dist - distribution tarball"
@ echo ""
.SUFFIXES: .c .o .i
.c.i:
$(CC) $(CFLAGS) -E $< > $@
#.c.o: $*.h $*.c
# $(CC) $(CFLAGS) -c $<
#---------------------------------------
$(LIBOBJS): $(LIBHDRS)
logtab.h: make-logtab
$(PERL) make-logtab > logtab.h
mpi.o: mpi.c logtab.h $(LIBHDRS)
mplogic.o: mplogic.c mpi-priv.h mplogic.h $(LIBHDRS)
mp_gf2m.o: mp_gf2m.c mpi-priv.h mp_gf2m.h mp_gf2m-priv.h $(LIBHDRS)
mpmontg.o: mpmontg.c mpi-priv.h mplogic.h mpprime.h $(LIBHDRS)
mpprime.o: mpprime.c mpi-priv.h mpprime.h mplogic.h primes.c $(LIBHDRS)
mpcpucache.o: mpcpucache.c $(LIBHDRS)
mpi_mips.o: mpi_mips.s
$(CC) -o $@ $(ASFLAGS) -c mpi_mips.s
mpi_sparc.o : montmulf.h
mpv_sparcv9.s: vis_64.il mpv_sparc.c
$(CC) -o $@ $(SOLARIS_FPU_FLAGS) -S vis_64.il mpv_sparc.c
mpv_sparcv8.s: vis_64.il mpv_sparc.c
$(CC) -o $@ $(SOLARIS_FPU_FLAGS) -S vis_32.il mpv_sparc.c
montmulfv8.o montmulfv9.o mpv_sparcv8.o mpv_sparcv9.o : %.o : %.s
$(CC) -o $@ $(SOLARIS_ASM_FLAGS) -c $<
mpi_arm.o: mpi_arm.c $(LIBHDRS)
# This rule is used to build the .s sources, which are then hand optimized.
#montmulfv8.s montmulfv9.s : montmulf%.s : montmulf%.il montmulf.c montmulf.h
# $(CC) -o $@ $(SOLARIS_ASM_FLAGS) -S montmulf$*.il montmulf.c
libmpi.a: $(LIBOBJS)
ar -cvr libmpi.a $(LIBOBJS)
$(RANLIB) libmpi.a
lib libs: libmpi.a
mpi.i: mpi.h
#---------------------------------------
MPTESTOBJS = mptest1.o mptest2.o mptest3.o mptest3a.o mptest4.o mptest4a.o \
mptest4b.o mptest6.o mptest7.o mptest8.o mptest9.o mptestb.o
MPTESTS = $(MPTESTOBJS:.o=)
$(MPTESTOBJS): mptest%.o: tests/mptest-%.c $(LIBHDRS)
$(CC) $(CFLAGS) -o $@ -c $<
$(MPTESTS): mptest%: mptest%.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
tests: mptest1 mptest2 mptest3 mptest3a mptest4 mptest4a mptest4b mptest6 \
mptestb bbsrand
utests: mptest7 mptest8 mptest9
#---------------------------------------
EXTRAOBJS = bbsrand.o bbs_rand.o prng.o
UTILOBJS = primegen.o metime.o identest.o basecvt.o fact.o exptmod.o pi.o \
makeprime.o gcd.o invmod.o lap.o isprime.o \
dec2hex.o hex2dec.o
UTILS = $(UTILOBJS:.o=)
$(UTILS): % : %.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
$(UTILOBJS) $(EXTRAOBJS): %.o : utils/%.c $(LIBHDRS)
$(CC) $(CFLAGS) -o $@ -c $<
prng: prng.o bbs_rand.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
bbsrand: bbsrand.o bbs_rand.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
utils: $(UTILS) prng bbsrand
#---------------------------------------
test-info.c: test-arrays.txt
$(PERL) make-test-arrays test-arrays.txt > test-info.c
mpi-test.o: mpi-test.c test-info.c $(LIBHDRS)
$(CC) $(CFLAGS) -o $@ -c $<
mpi-test: mpi-test.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
mdxptest.o: mdxptest.c $(LIBHDRS) mpi-priv.h
mdxptest: mdxptest.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
mulsqr.o: mulsqr.c logtab.h mpi.h mpi-config.h mpprime.h
$(CC) $(CFLAGS) -DMP_SQUARE=1 -o $@ -c mulsqr.c
mulsqr: mulsqr.o libmpi.a
$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
#---------------------------------------
alltests: tests utests mpi-test
tools: $(TOOLS)
doc:
(cd doc; ./build)
clean:
rm -f *.o *.a *.i
rm -f core
rm -f *~ .*~
rm -f utils/*.o
rm -f utils/core
rm -f utils/*~ utils/.*~
clobber: clean
rm -f $(TOOLS) $(UTILS)
distclean: clean
rm -f mptest? mpi-test metime mulsqr karatsuba
rm -f mptest?a mptest?b
rm -f utils/mptest?
rm -f test-info.c logtab.h
rm -f libmpi.a
rm -f $(TOOLS)
dist: Makefile $(HDRS) $(SRCS) $(DOCS)
tar -cvf mpi-$(VERS).tar Makefile $(HDRS) $(SRCS) $(DOCS)
pgps -ab mpi-$(VERS).tar
chmod +r mpi-$(VERS).tar.asc
gzip -9 mpi-$(VERS).tar
# END

243
security/nss/lib/freebl/mpi/Makefile.os2
View file

@ -1,243 +0,0 @@
#
# Makefile.win - gmake Makefile for building MPI with VACPP on OS/2
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
## Define CC to be the C compiler you wish to use. The GNU cc
## compiler (gcc) should work, at the very least
#CC=cc
#CC=gcc
CC=icc.exe
AS=alp.exe
##
## Define PERL to point to your local Perl interpreter. It
## should be Perl 5.x, although it's conceivable that Perl 4
## might work ... I haven't tested it.
##
#PERL=/usr/bin/perl
#PERL=perl
##
## Define CFLAGS to contain any local options your compiler
## setup requires.
##
## Conditional compilation options are no longer here; see
## the file 'mpi-config.h' instead.
##
MPICMN = -I. -DMP_API_COMPATIBLE -DMP_IOFUNC -DMP_USE_UINT_DIGIT -DMP_NO_MP_WORD
#OS/2
AS_SRCS = mpi_x86.asm
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE -DMP_ASSEMBLY_DIV_2DX1D
#CFLAGS= -Od -Z7 -MD -W3 -nologo -D_X86_ -DXP_PC \
-DDEBUG -D_DEBUG -UNDEBUG -DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
#CFLAGS = -O2 -MD -W3 -nologo -D_X86_ -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
-DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
#CFLAGS = -Od -Z7 -MD -W3 -nologo -D_X86_ -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
-DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
CFLAGS = /Ti+ -D_X86_ -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
$(MPICMN)
ASFLAGS =
##
## Define LIBS to include any libraries you need to link against.
## If NO_TABLE is define, LIBS should include '-lm' or whatever is
## necessary to bring in the math library. Otherwise, it can be
## left alone, unless your system has other peculiar requirements.
##
LIBS=#-lmalloc#-lefence#-lm
##
## Define RANLIB to be the library header randomizer; you might not
## need this on some systems (just set it to 'echo' on these systems,
## such as IRIX)
##
RANLIB=echo
##
## This is the version string used for the documentation and
## building the distribution tarball. Don't mess with it unless
## you are releasing a new version
VERS=1.7p6
## ----------------------------------------------------------------------
## You probably don't need to change anything below this line...
##
##
## This is the list of source files that need to be packed into
## the distribution file
SRCS= mpi.c mpprime.c mplogic.c mpmontg.c mpi-test.c primes.c tests/ \
utils/gcd.c utils/invmod.c utils/lap.c \
utils/ptab.pl utils/sieve.c utils/isprime.c\
utils/dec2hex.c utils/hex2dec.c utils/bbs_rand.c \
utils/bbsrand.c utils/prng.c utils/primegen.c \
utils/basecvt.c utils/makeprime.c\
utils/fact.c utils/exptmod.c utils/pi.c utils/metime.c \
utils/mpi.h utils/mpprime.h mulsqr.c \
make-test-arrays test-arrays.txt all-tests make-logtab \
types.pl stats timetest multest
## These are the header files that go into the distribution file
HDRS=mpi.h mpi-config.h utils/mpi.h utils/mpi-config.h mpprime.h mplogic.h \
utils/bbs_rand.h tests/mpi.h tests/mpprime.h
## These are the documentation files that go into the distribution file
DOCS=README doc utils/README utils/PRIMES
## This is the list of tools built by 'make tools'
TOOLS=gcd.exe invmod.exe isprime.exe lap.exe dec2hex.exe hex2dec.exe \
primegen.exe prng.exe basecvt.exe fact.exe exptmod.exe pi.exe makeprime.exe
AS_OBJS = $(AS_SRCS:.asm=.obj)
LIBOBJS = mpprime.obj mpmontg.obj mplogic.obj mpi.obj $(AS_OBJS)
LIBHDRS = mpi-config.h mpi-priv.h mpi.h
APPHDRS = mpi-config.h mpi.h mplogic.h mpprime.h
help:
@ echo ""
@ echo "The following targets can be built with this Makefile:"
@ echo ""
@ echo "mpi.lib - arithmetic and prime testing library"
@ echo "mpi-test.exe - test driver (requires MP_IOFUNC)"
@ echo "tools - command line tools"
@ echo "doc - manual pages for tools"
@ echo "clean - clean up objects and such"
@ echo "distclean - get ready for distribution"
@ echo "dist - distribution tarball"
@ echo ""
.SUFFIXES: .c .obj .i .lib .exe .asm
.c.i:
$(CC) $(CFLAGS) -E $< > $@
.c.obj:
$(CC) $(CFLAGS) -c $<
.asm.obj:
$(AS) $(ASFLAGS) $<
.obj.exe:
$(CC) $(CFLAGS) -Fo$@ $<
#---------------------------------------
$(LIBOBJS): $(LIBHDRS)
logtab.h: make-logtab
$(PERL) make-logtab > logtab.h
mpi.obj: mpi.c logtab.h $(LIBHDRS)
mplogic.obj: mplogic.c mpi-priv.h mplogic.h $(LIBHDRS)
mpmontg.obj: mpmontg.c mpi-priv.h mplogic.h mpprime.h $(LIBHDRS)
mpprime.obj: mpprime.c mpi-priv.h mpprime.h mplogic.h primes.c $(LIBHDRS)
mpi_mips.obj: mpi_mips.s
$(CC) -Fo$@ $(ASFLAGS) -c mpi_mips.s
mpi.lib: $(LIBOBJS)
ilib /out:mpi.lib $(LIBOBJS)
$(RANLIB) mpi.lib
lib libs: mpi.lib
#---------------------------------------
MPTESTOBJS = mptest1.obj mptest2.obj mptest3.obj mptest3a.obj mptest4.obj \
mptest4a.obj mptest4b.obj mptest6.obj mptest7.obj mptest8.obj mptest9.obj
MPTESTS = $(MPTESTOBJS:.obj=.exe)
$(MPTESTOBJS): mptest%.obj: tests/mptest-%.c $(LIBHDRS)
$(CC) $(CFLAGS) -Fo$@ -c $<
$(MPTESTS): mptest%.exe: mptest%.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
tests: mptest1.exe mptest2.exe mptest3.exe mptest3a.exe mptest4.exe \
mptest4a.exe mptest4b.exe mptest6.exe bbsrand.exe
utests: mptest7.exe mptest8.exe mptest9.exe
#---------------------------------------
EXTRAOBJS = bbsrand.obj bbs_rand.obj prng.obj
UTILOBJS = primegen.obj metime.obj identest.obj basecvt.obj fact.obj \
exptmod.obj pi.obj makeprime.obj karatsuba.obj gcd.obj invmod.obj lap.obj \
isprime.obj dec2hex.obj hex2dec.obj
UTILS = $(UTILOBJS:.obj=.exe)
$(UTILS): %.exe : %.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
$(UTILOBJS) $(EXTRAOBJS): %.obj : utils/%.c $(LIBHDRS)
$(CC) $(CFLAGS) -Fo$@ -c $<
prng.exe: prng.obj bbs_rand.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
bbsrand.exe: bbsrand.obj bbs_rand.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
utils: $(UTILS) prng.exe bbsrand.exe
#---------------------------------------
test-info.c: test-arrays.txt
$(PERL) make-test-arrays test-arrays.txt > test-info.c
mpi-test.obj: mpi-test.c test-info.c $(LIBHDRS)
$(CC) $(CFLAGS) -Fo$@ -c $<
mpi-test.exe: mpi-test.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
mdxptest.obj: mdxptest.c $(LIBHDRS) mpi-priv.h
mdxptest.exe: mdxptest.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
mulsqr.obj: mulsqr.c logtab.h mpi.h mpi-config.h mpprime.h
$(CC) $(CFLAGS) -DMP_SQUARE=1 -Fo$@ -c mulsqr.c
mulsqr.exe: mulsqr.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
#---------------------------------------
alltests: tests utests mpi-test.exe
tools: $(TOOLS)
doc:
(cd doc; ./build)
clean:
rm -f *.obj *.lib *.pdb *.ilk
cd utils; rm -f *.obj *.lib *.pdb *.ilk
distclean: clean
rm -f mptest? mpi-test metime mulsqr karatsuba
rm -f mptest?a mptest?b
rm -f utils/mptest?
rm -f test-info.c logtab.h
rm -f mpi.lib
rm -f $(TOOLS)
dist: Makefile $(HDRS) $(SRCS) $(DOCS)
tar -cvf mpi-$(VERS).tar Makefile $(HDRS) $(SRCS) $(DOCS)
pgps -ab mpi-$(VERS).tar
chmod +r mpi-$(VERS).tar.asc
gzip -9 mpi-$(VERS).tar
print:
@echo LIBOBJS = $(LIBOBJS)
# END

254
security/nss/lib/freebl/mpi/Makefile.win
View file

@ -1,254 +0,0 @@
#
# Makefile.win - gmake Makefile for building MPI with MSVC on NT
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
## Define CC to be the C compiler you wish to use. The GNU cc
## compiler (gcc) should work, at the very least
#CC=cc
#CC=gcc
CC=cl.exe
ifeq ($(CPU_ARCH),x86_64)
AS=ml64.exe
else
AS=ml.exe
endif
##
## Define PERL to point to your local Perl interpreter. It
## should be Perl 5.x, although it's conceivable that Perl 4
## might work ... I haven't tested it.
##
#PERL=/usr/bin/perl
#PERL=perl
##
## Define CFLAGS to contain any local options your compiler
## setup requires.
##
## Conditional compilation options are no longer here; see
## the file 'mpi-config.h' instead.
##
MPICMN = -I. -DMP_API_COMPATIBLE -DMP_IOFUNC
ifeq ($(CPU_ARCH),x86_64)
AS_SRCS = mpi_x86_64.asm
CFLAGS = -O2 -Z7 -MD -W3 -nologo -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
-DWIN32 -D_WIN64 -D_AMD64_ -D_M_AMD64 -D_WINDOWS -DWIN95 $(MPICMN)
ASFLAGS = -Cp -Sn -Zi -I.
else
#NT
AS_SRCS = mpi_x86.asm
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE -DMP_ASSEMBLY_DIV_2DX1D
#CFLAGS= -Od -Z7 -MD -W3 -nologo -D_X86_ -DXP_PC \
-DDEBUG -D_DEBUG -UNDEBUG -DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
#CFLAGS = -O2 -MD -W3 -nologo -D_X86_ -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
-DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
#CFLAGS = -Od -Z7 -MD -W3 -nologo -D_X86_ -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
-DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
CFLAGS = -O2 -Z7 -MD -W3 -nologo -D_X86_ -DXP_PC -UDEBUG -U_DEBUG -DNDEBUG \
-DWIN32 -D_WINDOWS -DWIN95 $(MPICMN)
ASFLAGS = -Cp -Sn -Zi -coff -I.
endif
##
## Define LIBS to include any libraries you need to link against.
## If NO_TABLE is define, LIBS should include '-lm' or whatever is
## necessary to bring in the math library. Otherwise, it can be
## left alone, unless your system has other peculiar requirements.
##
LIBS=#-lmalloc#-lefence#-lm
##
## Define RANLIB to be the library header randomizer; you might not
## need this on some systems (just set it to 'echo' on these systems,
## such as IRIX)
##
RANLIB=echo
##
## This is the version string used for the documentation and
## building the distribution tarball. Don't mess with it unless
## you are releasing a new version
VERS=1.7p6
## ----------------------------------------------------------------------
## You probably don't need to change anything below this line...
##
##
## This is the list of source files that need to be packed into
## the distribution file
SRCS= mpi.c mpprime.c mplogic.c mpmontg.c mpi-test.c primes.c tests/ \
utils/gcd.c utils/invmod.c utils/lap.c \
utils/ptab.pl utils/sieve.c utils/isprime.c\
utils/dec2hex.c utils/hex2dec.c utils/bbs_rand.c \
utils/bbsrand.c utils/prng.c utils/primegen.c \
utils/basecvt.c utils/makeprime.c\
utils/fact.c utils/exptmod.c utils/pi.c utils/metime.c \
utils/mpi.h utils/mpprime.h mulsqr.c \
make-test-arrays test-arrays.txt all-tests make-logtab \
types.pl stats timetest multest
## These are the header files that go into the distribution file
HDRS=mpi.h mpi-config.h utils/mpi.h utils/mpi-config.h mpprime.h mplogic.h \
utils/bbs_rand.h tests/mpi.h tests/mpprime.h
## These are the documentation files that go into the distribution file
DOCS=README doc utils/README utils/PRIMES
## This is the list of tools built by 'make tools'
TOOLS=gcd.exe invmod.exe isprime.exe lap.exe dec2hex.exe hex2dec.exe \
primegen.exe prng.exe basecvt.exe fact.exe exptmod.exe pi.exe makeprime.exe
AS_OBJS = $(AS_SRCS:.asm=.obj)
LIBOBJS = mpprime.obj mpmontg.obj mplogic.obj mpi.obj $(AS_OBJS)
LIBHDRS = mpi-config.h mpi-priv.h mpi.h
APPHDRS = mpi-config.h mpi.h mplogic.h mpprime.h
help:
@ echo ""
@ echo "The following targets can be built with this Makefile:"
@ echo ""
@ echo "mpi.lib - arithmetic and prime testing library"
@ echo "mpi-test - test driver (requires MP_IOFUNC)"
@ echo "tools - command line tools"
@ echo "doc - manual pages for tools"
@ echo "clean - clean up objects and such"
@ echo "distclean - get ready for distribution"
@ echo "dist - distribution tarball"
@ echo ""
.SUFFIXES: .c .obj .i .lib .exe .asm
.c.i:
$(CC) $(CFLAGS) -E $< > $@
.c.obj:
$(CC) $(CFLAGS) -c $<
.asm.obj:
$(AS) $(ASFLAGS) -c $<
.obj.exe:
$(CC) $(CFLAGS) -Fo$@ $<
#---------------------------------------
$(LIBOBJS): $(LIBHDRS)
logtab.h: make-logtab
$(PERL) make-logtab > logtab.h
mpi.obj: mpi.c logtab.h $(LIBHDRS)
mplogic.obj: mplogic.c mpi-priv.h mplogic.h $(LIBHDRS)
mpmontg.obj: mpmontg.c mpi-priv.h mplogic.h mpprime.h $(LIBHDRS)
mpprime.obj: mpprime.c mpi-priv.h mpprime.h mplogic.h primes.c $(LIBHDRS)
mpi_mips.obj: mpi_mips.s
$(CC) -Fo$@ $(ASFLAGS) -c mpi_mips.s
mpi.lib: $(LIBOBJS)
ar -cvr mpi.lib $(LIBOBJS)
$(RANLIB) mpi.lib
lib libs: mpi.lib
#---------------------------------------
MPTESTOBJS = mptest1.obj mptest2.obj mptest3.obj mptest3a.obj mptest4.obj \
mptest4a.obj mptest4b.obj mptest6.obj mptest7.obj mptest8.obj mptest9.obj
MPTESTS = $(MPTESTOBJS:.obj=.exe)
$(MPTESTOBJS): mptest%.obj: tests/mptest-%.c $(LIBHDRS)
$(CC) $(CFLAGS) -Fo$@ -c $<
$(MPTESTS): mptest%.exe: mptest%.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
tests: mptest1.exe mptest2.exe mptest3.exe mptest3a.exe mptest4.exe \
mptest4a.exe mptest4b.exe mptest6.exe bbsrand.exe
utests: mptest7.exe mptest8.exe mptest9.exe
#---------------------------------------
EXTRAOBJS = bbsrand.obj bbs_rand.obj prng.obj
UTILOBJS = primegen.obj metime.obj identest.obj basecvt.obj fact.obj \
exptmod.obj pi.obj makeprime.obj karatsuba.obj gcd.obj invmod.obj lap.obj \
isprime.obj dec2hex.obj hex2dec.obj
UTILS = $(UTILOBJS:.obj=.exe)
$(UTILS): %.exe : %.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
$(UTILOBJS) $(EXTRAOBJS): %.obj : utils/%.c $(LIBHDRS)
$(CC) $(CFLAGS) -Fo$@ -c $<
prng.exe: prng.obj bbs_rand.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
bbsrand.exe: bbsrand.obj bbs_rand.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
utils: $(UTILS) prng.exe bbsrand.exe
#---------------------------------------
test-info.c: test-arrays.txt
$(PERL) make-test-arrays test-arrays.txt > test-info.c
mpi-test.obj: mpi-test.c test-info.c $(LIBHDRS)
$(CC) $(CFLAGS) -Fo$@ -c $<
mpi-test.exe: mpi-test.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
mdxptest.obj: mdxptest.c $(LIBHDRS) mpi-priv.h
mdxptest.exe: mdxptest.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
mulsqr.obj: mulsqr.c logtab.h mpi.h mpi-config.h mpprime.h
$(CC) $(CFLAGS) -DMP_SQUARE=1 -Fo$@ -c mulsqr.c
mulsqr.exe: mulsqr.obj mpi.lib $(LIBS)
$(CC) $(CFLAGS) -Fo$@ $^
#---------------------------------------
alltests: tests utests mpi-test.exe
tools: $(TOOLS)
doc:
(cd doc; ./build)
clean:
rm -f *.obj *.lib *.pdb *.ilk
cd utils; rm -f *.obj *.lib *.pdb *.ilk
distclean: clean
rm -f mptest? mpi-test metime mulsqr karatsuba
rm -f mptest?a mptest?b
rm -f utils/mptest?
rm -f test-info.c logtab.h
rm -f mpi.lib
rm -f $(TOOLS)
dist: Makefile $(HDRS) $(SRCS) $(DOCS)
tar -cvf mpi-$(VERS).tar Makefile $(HDRS) $(SRCS) $(DOCS)
pgps -ab mpi-$(VERS).tar
chmod +r mpi-$(VERS).tar.asc
gzip -9 mpi-$(VERS).tar
print:
@echo LIBOBJS = $(LIBOBJS)
# END

97
security/nss/lib/freebl/mpi/README
View file

@ -67,14 +67,6 @@ assumptions about the sizes of things, but there is little if any
reason to change the other parameters, so I would recommend you leave
them as you found them.
The library comes with a Perl script, 'types.pl', which will scan your
current Makefile settings, and attempt to find good definitions for
these types. It relies on a Unix sort of build environment, so it
probably won't work under MacOS or Windows, but it can be convenient
if you're porting to a new flavour of Unix. Just run 'types.pl' at
the command line, and it will spit out its results to the standard
output.
Conventions
-----------
@ -503,9 +495,6 @@ MP_MODARITH - Define true to include the modular arithmetic
in your application, you can set this to zero to
leave out all the modular routines.
MP_NUMTH - Define true to include number theoretic functions
such as mp_gcd(), mp_lcm(), and mp_invmod().
MP_LOGTAB - If true, the file "logtab.h" is included, which
is basically a static table of base 2 logarithms.
These are used to compute how big the buffers for
@ -633,92 +622,6 @@ Most of these can be built from the Makefile that comes with the
library. Try 'make tools', if your environment supports it.
Testing the Library
-------------------
Automatic test vectors are included, in the form of a program called
'mpi-test'. To build this program and run all the tests, simply
invoke the shell script 'all-tests'. If all the tests pass, you
should see a message:
All tests passed
If something went wrong, you'll get:
One or more tests failed.
If this happens, scan back through the preceding lines, to see which
test failed. Any failure indicates a bug in the library, which needs
to be fixed before it will give accurate results. If you get any such
thing, please let me know, and I'll try to fix it. Please let me know
what platform and compiler you were using, as well as which test
failed. If a reason for failure was given, please send me that text
as well.
If you're on a system where the standard Unix build tools don't work,
you can build the 'mpi-test' program manually, and run it by hand.
This is tedious and obnoxious, sorry.
Further manual testing can be performed by building the manual testing
programs, whose source is found in the 'tests' subdirectory. Each
test is in a source file called 'mptest-X.c'. The Makefile contains a
target to build all of them at once:
make tests
Read the comments at the top of each source file to see what the
driver is supposed to test. You probably don't need to do this; these
programs were only written to help me as I was developing the library.
The relevant files are:
mpi-test.c The source for the test driver
make-test-arrays A Perl script to generate some of the internal
data structures used by mpi-test.c
test-arrays.txt The source file for make-test-arrays
all-tests A Bourne shell script which runs all the
tests in the mpi-test suite
Running 'make mpi-test' should build the mpi-test program. If you
cannot use make, here is what needs to be done:
(1) Use 'make-test-arrays' to generate the file 'test-info.c' from
the 'test-arrays.txt' file. Since Perl can be found everywhere,
this should be no trouble. Under Unix, this looks like:
make-test-arrays test-arrays.txt > test-info.c
(2) Build the MPI library:
gcc -ansi -pedantic -Wall -c mpi.c
(3) Build the mpi-test program:
gcc -ansi -pedantic -Wall -o mpi-test mpi.o mpi-test.c
When you've got mpi-test, you can use 'all-tests' to run all the tests
made available by mpi-test. If any of them fail, there should be a
diagnostic indicating what went wrong. These are fairly high-level
diagnostics, and won't really help you debug the problem; they're
simply intended to help you isolate which function caused the problem.
If you encounter a problem of this sort, feel free to e-mail me, and I
will certainly attempt to help you debug it.
Note: Several of the tests hard-wired into 'mpi-test' operate under
---- the assumption that you are using at least a 16-bit mp_digit
type. If that is not true, several tests might fail, because
of range problems with the maximum digit value.
If you are using an 8-bit digit, you will also need to
modify the code for mp_read_raw(), which assumes that
multiplication by 256 can be done with mp_mul_d(), a
fact that fails when DIGIT_MAX is 255. You can replace
the call with s_mp_lshd(), which will give you the same
effect, and without doing as much work. :)
Acknowledgements:
----------------

83
security/nss/lib/freebl/mpi/all-tests
View file

@ -1,83 +0,0 @@
#!/bin/sh
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
ECHO=/bin/echo
MAKE=gmake
$ECHO "\n** Running unit tests for MPI library\n"
# Build the mpi-test program, which comprises all the unit tests for
# the MPI library...
$ECHO "Bringing mpi-test up to date ... "
if $MAKE mpi-test ; then
:
else
$ECHO " "
$ECHO "Make failed to build mpi-test."
$ECHO " "
exit 1
fi
if [ ! -x mpi-test ] ; then
$ECHO " "
$ECHO "Cannot find 'mpi-test' program, testing cannot continue."
$ECHO " "
exit 1
fi
# Get the list of available test suites...
tests=`./mpi-test list | awk '{print $1}'`
errs=0
# Run each test suite and check the result code of mpi-test
for test in $tests ; do
$ECHO "$test ... \c"
if ./mpi-test $test ; then
$ECHO "passed"
else
$ECHO "FAILED"
errs=1
fi
done
# If any tests failed, we'll stop at this point
if [ "$errs" = "0" ] ; then
$ECHO "All unit tests passed"
else
$ECHO "One or more tests failed"
exit 1
fi
# Now try to build the 'pi' program, and see if it can compute the
# first thousand digits of pi correctly
$ECHO "\n** Running other tests\n"
$ECHO "Bringing 'pi' up to date ... "
if $MAKE pi ; then
:
else
$ECHO "\nMake failed to build pi.\n"
exit 1
fi
if [ ! -x pi ] ; then
$ECHO "\nCannot find 'pi' program; testing cannot continue.\n"
exit 1
fi
./pi 2000 > /tmp/pi.tmp.$$
if cmp tests/pi2k.txt /tmp/pi.tmp.$$ ; then
$ECHO "Okay! The pi test passes."
else
$ECHO "Oops! The pi test failed. :("
exit 1
fi
rm -f /tmp/pi.tmp.$$
exit 0
# Here there be dragons

21
security/nss/lib/freebl/mpi/hppatch.adb
View file

@ -1,21 +0,0 @@
#/bin/sh
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
# script to change the system id in an object file from PA-RISC 2.0 to 1.1
adb -w $1 << EOF
?m 0 -1 0
0x0?X
0x0?W (@0x0&~0x40000)|(~@0x0&0x40000)
0?"change checksum"
0x7c?X
0x7c?W (@0x7c&~0x40000)|(~@0x7c&0x40000)
$q
EOF
exit 0

29
security/nss/lib/freebl/mpi/make-logtab
View file

@ -1,29 +0,0 @@
#!/usr/bin/perl
#
# make-logtab
#
# Generate a table of logarithms of 2 in various bases, for use in
# estimating the output sizes of various bases.
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
$ARRAYNAME = $ENV{'ARRAYNAME'} || "s_logv_2";
$ARRAYTYPE = $ENV{'ARRAYTYPE'} || "float";
printf("const %s %s[] = {\n %0.9ff, %0.9ff, ",
$ARRAYTYPE, $ARRAYNAME, 0, 0);
$brk = 2;
for($ix = 2; $ix < 64; $ix++) {
printf("%0.9ff, ", (log(2)/log($ix)));
$brk = ($brk + 1) & 3;
if(!$brk) {
printf(" /* %2d %2d %2d %2d */\n ",
$ix - 3, $ix - 2, $ix - 1, $ix);
}
}
printf("%0.9ff\n};\n\n", (log(2)/log($ix)));
exit 0;

98
security/nss/lib/freebl/mpi/make-test-arrays
View file

@ -1,98 +0,0 @@
#!/usr/bin/perl
#
# make-test-arrays
#
# Given a test-arrays file, which specifies the test suite names, the
# names of the functions which perform those test suites, and
# descriptive comments, this script generates C structures for the
# mpi-test program. The input consists of lines of the form:
#
# suite-name:function-name:comment
#
# The output is written to the standard output. Blank lines are
# ignored, and comments beginning with '#' are stripped.
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
# Read parameters from the environment, if available
$NAMEVAR = $ENV{'NAMEVAR'} || "g_names";
$COUNTVAR = $ENV{'COUNTVAR'} || "g_count";
$FUNCVAR = $ENV{'FUNCVAR'} || "g_tests";
$DESCVAR = $ENV{'DESCVAR'} || "g_descs";
$FUNCLEN = 13;
$NAMELEN = 18;
$DESCLEN = 45;
#------------------------------------------------------------------------
# Suck in input from the files on the command line, or standard input
while(<>) {
chomp;
s/\#.*$//;
next if /^\s*$/;
($suite, $func, $desc) = split(/:/, $_);
$tmp = { "suite" => $suite,
"func" => $func,
"desc" => $desc };
push(@item, $tmp);
}
$count = scalar(@item);
$last = pop(@item);
#------------------------------------------------------------------------
# Output the table of names
print "/* Table mapping test suite names to index numbers */\n";
printf("const int %s = %d;\n", $COUNTVAR, $count);
printf("const char *%s[] = {\n", $NAMEVAR);
foreach $elt (@item) {
printf(" \"%s\",%s/* %s%s */\n", $elt->{"suite"},
" " x ($NAMELEN - length($elt->{"suite"})),
$elt->{"desc"},
" " x ($DESCLEN - length($elt->{"desc"})));
}
printf(" \"%s\" %s/* %s%s */\n", $last->{"suite"},
" " x ($NAMELEN - length($last->{"suite"})),
$last->{"desc"},
" " x ($DESCLEN - length($last->{"desc"})));
print "};\n\n";
#------------------------------------------------------------------------
# Output the driver function prototypes
print "/* Test function prototypes */\n";
foreach $elt (@item, $last) {
printf("int %s(void);\n", $elt->{"func"});
}
print "\n";
#------------------------------------------------------------------------
# Output the table of functions
print "/* Table mapping index numbers to functions */\n";
printf("int (*%s[])(void) = {\n ", $FUNCVAR);
$brk = 0;
foreach $elt (@item) {
print($elt->{"func"}, ", ",
" " x ($FUNCLEN - length($elt->{"func"})));
$brk = ($brk + 1) & 3;
print "\n " unless($brk);
}
print $last->{"func"}, "\n};\n\n";
#------------------------------------------------------------------------
# Output the table of descriptions
print "/* Table mapping index numbers to descriptions */\n";
printf("const char *%s[] = {\n", $DESCVAR);
foreach $elt (@item) {
printf(" \"%s\",\n", $elt->{"desc"});
}
printf(" \"%s\"\n};\n\n", $last->{"desc"});
exit 0;

306
security/nss/lib/freebl/mpi/mdxptest.c
View file

@ -1,306 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "mpi.h"
#include "mpi-priv.h"
/* #define OLD_WAY 1 */
/* This key is the 1024-bit test key used for speed testing of RSA private
** key ops.
*/
#define CONST const
static CONST unsigned char default_n[128] = {
0xc2, 0xae, 0x96, 0x89, 0xaf, 0xce, 0xd0, 0x7b, 0x3b, 0x35, 0xfd, 0x0f, 0xb1, 0xf4, 0x7a, 0xd1,
0x3c, 0x7d, 0xb5, 0x86, 0xf2, 0x68, 0x36, 0xc9, 0x97, 0xe6, 0x82, 0x94, 0x86, 0xaa, 0x05, 0x39,
0xec, 0x11, 0x51, 0xcc, 0x5c, 0xa1, 0x59, 0xba, 0x29, 0x18, 0xf3, 0x28, 0xf1, 0x9d, 0xe3, 0xae,
0x96, 0x5d, 0x6d, 0x87, 0x73, 0xf6, 0xf6, 0x1f, 0xd0, 0x2d, 0xfb, 0x2f, 0x7a, 0x13, 0x7f, 0xc8,
0x0c, 0x7a, 0xe9, 0x85, 0xfb, 0xce, 0x74, 0x86, 0xf8, 0xef, 0x2f, 0x85, 0x37, 0x73, 0x0f, 0x62,
0x4e, 0x93, 0x17, 0xb7, 0x7e, 0x84, 0x9a, 0x94, 0x11, 0x05, 0xca, 0x0d, 0x31, 0x4b, 0x2a, 0xc8,
0xdf, 0xfe, 0xe9, 0x0c, 0x13, 0xc7, 0xf2, 0xad, 0x19, 0x64, 0x28, 0x3c, 0xb5, 0x6a, 0xc8, 0x4b,
0x79, 0xea, 0x7c, 0xce, 0x75, 0x92, 0x45, 0x3e, 0xa3, 0x9d, 0x64, 0x6f, 0x04, 0x69, 0x19, 0x17
};
static CONST unsigned char default_d[128] = {
0x13, 0xcb, 0xbc, 0xf2, 0xf3, 0x35, 0x8c, 0x6d, 0x7b, 0x6f, 0xd9, 0xf3, 0xa6, 0x9c, 0xbd, 0x80,
0x59, 0x2e, 0x4f, 0x2f, 0x11, 0xa7, 0x17, 0x2b, 0x18, 0x8f, 0x0f, 0xe8, 0x1a, 0x69, 0x5f, 0x6e,
0xac, 0x5a, 0x76, 0x7e, 0xd9, 0x4c, 0x6e, 0xdb, 0x47, 0x22, 0x8a, 0x57, 0x37, 0x7a, 0x5e, 0x94,
0x7a, 0x25, 0xb5, 0xe5, 0x78, 0x1d, 0x3c, 0x99, 0xaf, 0x89, 0x7d, 0x69, 0x2e, 0x78, 0x9d, 0x1d,
0x84, 0xc8, 0xc1, 0xd7, 0x1a, 0xb2, 0x6d, 0x2d, 0x8a, 0xd9, 0xab, 0x6b, 0xce, 0xae, 0xb0, 0xa0,
0x58, 0x55, 0xad, 0x5c, 0x40, 0x8a, 0xd6, 0x96, 0x08, 0x8a, 0xe8, 0x63, 0xe6, 0x3d, 0x6c, 0x20,
0x49, 0xc7, 0xaf, 0x0f, 0x25, 0x73, 0xd3, 0x69, 0x43, 0x3b, 0xf2, 0x32, 0xf8, 0x3d, 0x5e, 0xee,
0x7a, 0xca, 0xd6, 0x94, 0x55, 0xe5, 0xbd, 0x25, 0x34, 0x8d, 0x63, 0x40, 0xb5, 0x8a, 0xc3, 0x01
};
#define DEFAULT_ITERS 50
typedef clock_t timetype;
#define gettime(x) *(x) = clock()
#define subtime(a, b) a -= b
#define msec(x) ((clock_t)((double)x * 1000.0 / CLOCKS_PER_SEC))
#define sec(x) (x / CLOCKS_PER_SEC)
struct TimingContextStr {
timetype start;
timetype end;
timetype interval;
int minutes;
int seconds;
int millisecs;
};
typedef struct TimingContextStr TimingContext;
TimingContext *
CreateTimingContext(void)
{
return (TimingContext *)malloc(sizeof(TimingContext));
}
void
DestroyTimingContext(TimingContext *ctx)
{
free(ctx);
}
void
TimingBegin(TimingContext *ctx)
{
gettime(&ctx->start);
}
static void
timingUpdate(TimingContext *ctx)
{
ctx->millisecs = msec(ctx->interval) % 1000;
ctx->seconds = sec(ctx->interval);
ctx->minutes = ctx->seconds / 60;
ctx->seconds %= 60;
}
void
TimingEnd(TimingContext *ctx)
{
gettime(&ctx->end);
ctx->interval = ctx->end;
subtime(ctx->interval, ctx->start);
timingUpdate(ctx);
}
char *
TimingGenerateString(TimingContext *ctx)
{
static char sBuf[4096];
sprintf(sBuf, "%d minutes, %d.%03d seconds", ctx->minutes,
ctx->seconds, ctx->millisecs);
return sBuf;
}
static void
dumpBytes(unsigned char *b, int l)
{
int i;
if (l <= 0)
return;
for (i = 0; i < l; ++i) {
if (i % 16 == 0)
printf("\t");
printf(" %02x", b[i]);
if (i % 16 == 15)
printf("\n");
}
if ((i % 16) != 0)
printf("\n");
printf("\n");
}
static mp_err
testNewFuncs(const unsigned char *modulusBytes, int modulus_len)
{
mp_err mperr = MP_OKAY;
mp_int modulus;
unsigned char buf[512];
mperr = mp_init(&modulus);
mperr = mp_read_unsigned_octets(&modulus, modulusBytes, modulus_len);
mperr = mp_to_fixlen_octets(&modulus, buf, modulus_len);
mperr = mp_to_fixlen_octets(&modulus, buf, modulus_len + 1);
mperr = mp_to_fixlen_octets(&modulus, buf, modulus_len + 4);
mperr = mp_to_unsigned_octets(&modulus, buf, modulus_len);
mperr = mp_to_signed_octets(&modulus, buf, modulus_len + 1);
mp_clear(&modulus);
return mperr;
}
int
testModExp(const unsigned char *modulusBytes,
const unsigned int expo,
const unsigned char *input,
unsigned char *output,
int modulus_len)
{
mp_err mperr = MP_OKAY;
mp_int modulus;
mp_int base;
mp_int exponent;
mp_int result;
mperr = mp_init(&modulus);
mperr += mp_init(&base);
mperr += mp_init(&exponent);
mperr += mp_init(&result);
/* we initialize all mp_ints unconditionally, even if some fail.
** This guarantees that the DIGITS pointer is valid (even if null).
** So, mp_clear will do the right thing below.
*/
if (mperr == MP_OKAY) {
mperr = mp_read_unsigned_octets(&modulus,
modulusBytes + (sizeof default_n - modulus_len), modulus_len);
mperr += mp_read_unsigned_octets(&base, input, modulus_len);
mp_set(&exponent, expo);
if (mperr == MP_OKAY) {
#if OLD_WAY
mperr = s_mp_exptmod(&base, &exponent, &modulus, &result);
#else
mperr = mp_exptmod(&base, &exponent, &modulus, &result);
#endif
if (mperr == MP_OKAY) {
mperr = mp_to_fixlen_octets(&result, output, modulus_len);
}
}
}
mp_clear(&base);
mp_clear(&result);
mp_clear(&modulus);
mp_clear(&exponent);
return (int)mperr;
}
int
doModExp(const unsigned char *modulusBytes,
const unsigned char *exponentBytes,
const unsigned char *input,
unsigned char *output,
int modulus_len)
{
mp_err mperr = MP_OKAY;
mp_int modulus;
mp_int base;
mp_int exponent;
mp_int result;
mperr = mp_init(&modulus);
mperr += mp_init(&base);
mperr += mp_init(&exponent);
mperr += mp_init(&result);
/* we initialize all mp_ints unconditionally, even if some fail.
** This guarantees that the DIGITS pointer is valid (even if null).
** So, mp_clear will do the right thing below.
*/
if (mperr == MP_OKAY) {
mperr = mp_read_unsigned_octets(&modulus,
modulusBytes + (sizeof default_n - modulus_len), modulus_len);
mperr += mp_read_unsigned_octets(&exponent, exponentBytes, modulus_len);
mperr += mp_read_unsigned_octets(&base, input, modulus_len);
if (mperr == MP_OKAY) {
#if OLD_WAY
mperr = s_mp_exptmod(&base, &exponent, &modulus, &result);
#else
mperr = mp_exptmod(&base, &exponent, &modulus, &result);
#endif
if (mperr == MP_OKAY) {
mperr = mp_to_fixlen_octets(&result, output, modulus_len);
}
}
}
mp_clear(&base);
mp_clear(&result);
mp_clear(&modulus);
mp_clear(&exponent);
return (int)mperr;
}
int
main(int argc, char **argv)
{
TimingContext *timeCtx;
char *progName;
long iters = DEFAULT_ITERS;
unsigned int modulus_len;
int i;
int rv;
unsigned char buf[1024];
unsigned char buf2[1024];
progName = strrchr(argv[0], '/');
if (!progName)
progName = strrchr(argv[0], '\\');
progName = progName ? progName + 1 : argv[0];
if (argc >= 2) {
iters = atol(argv[1]);
}
if (argc >= 3) {
modulus_len = atol(argv[2]);
} else
modulus_len = sizeof default_n;
/* no library init function !? */
memset(buf, 0x41, sizeof buf);
if (iters < 2) {
testNewFuncs(default_n, modulus_len);
testNewFuncs(default_n + 1, modulus_len - 1);
testNewFuncs(default_n + 2, modulus_len - 2);
testNewFuncs(default_n + 3, modulus_len - 3);
rv = testModExp(default_n, 0, buf, buf2, modulus_len);
dumpBytes((unsigned char *)buf2, modulus_len);
rv = testModExp(default_n, 1, buf, buf2, modulus_len);
dumpBytes((unsigned char *)buf2, modulus_len);
rv = testModExp(default_n, 2, buf, buf2, modulus_len);
dumpBytes((unsigned char *)buf2, modulus_len);
rv = testModExp(default_n, 3, buf, buf2, modulus_len);
dumpBytes((unsigned char *)buf2, modulus_len);
}
rv = doModExp(default_n, default_d, buf, buf2, modulus_len);
if (rv != 0) {
fprintf(stderr, "Error in modexp operation:\n");
exit(1);
}
dumpBytes((unsigned char *)buf2, modulus_len);
timeCtx = CreateTimingContext();
TimingBegin(timeCtx);
i = iters;
while (i--) {
rv = doModExp(default_n, default_d, buf, buf2, modulus_len);
if (rv != 0) {
fprintf(stderr, "Error in modexp operation\n");
exit(1);
}
}
TimingEnd(timeCtx);
printf("%ld iterations in %s\n", iters, TimingGenerateString(timeCtx));
return 0;
}

23
security/nss/lib/freebl/mpi/mpcpucache.c
View file

@ -17,7 +17,7 @@
*
* Currently the file returns good data for most modern x86 processors, and
* reasonable data on 64-bit ppc processors. All other processors are assumed
* to have a cache line size of 32 bytes unless modified by target.mk.
* to have a cache line size of 32 bytes.
*
*/
@ -775,18 +775,6 @@ s_mpi_getProcessorLineSize()
*
*/
/* target.mk can define MPI_CACHE_LINE_SIZE if it's common for the family or
* OS */
#if defined(MPI_CACHE_LINE_SIZE) && !defined(MPI_GET_PROCESSOR_LINE_SIZE_DEFINED)
unsigned long
s_mpi_getProcessorLineSize()
{
return MPI_CACHE_LINE_SIZE;
}
#define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
#endif
/* If no way to get the processor cache line size has been defined, assume
* it's 32 bytes (most common value, does not significantly impact performance)
*/
@ -797,12 +785,3 @@ s_mpi_getProcessorLineSize()
return 32;
}
#endif
#ifdef TEST_IT
#include <stdio.h>
main()
{
printf("line size = %d\n", s_mpi_getProcessorLineSize());
}
#endif

4
security/nss/lib/freebl/mpi/mpi-config.h
View file

@ -24,10 +24,6 @@
#define MP_MODARITH 1 /* include modular arithmetic ? */
#endif
#ifndef MP_NUMTH
#define MP_NUMTH 1 /* include number theoretic functions? */
#endif
#ifndef MP_LOGTAB
#define MP_LOGTAB 1 /* use table of logs instead of log()? */
#endif

52
security/nss/lib/freebl/mpi/mpi.c
View file

@ -1695,7 +1695,6 @@ mp_iseven(const mp_int *a)
/*------------------------------------------------------------------------*/
/* {{{ Number theoretic functions */
#if MP_NUMTH
/* {{{ mp_gcd(a, b, c) */
/*
@ -2376,7 +2375,6 @@ mp_invmod(const mp_int *a, const mp_int *m, mp_int *c)
} /* end mp_invmod() */
/* }}} */
#endif /* if MP_NUMTH */
/* }}} */
@ -2861,6 +2859,9 @@ void
s_mp_exch(mp_int *a, mp_int *b)
{
mp_int tmp;
if (!a || !b) {
return;
}
tmp = *a;
*a = *b;
@ -4088,7 +4089,7 @@ s_mpv_sqr_add_prop(const mp_digit *pa, mp_size a_len, mp_digit *ps)
}
#endif
#if (defined(MP_NO_MP_WORD) || defined(MP_NO_DIV_WORD)) && !defined(MP_ASSEMBLY_DIV_2DX1D)
#if !defined(MP_ASSEMBLY_DIV_2DX1D)
/*
** Divide 64-bit (Nhi,Nlo) by 32-bit divisor, which must be normalized
** so its high bit is 1. This code is from NSPR.
@ -4166,11 +4167,7 @@ mp_err s_mp_div(mp_int *rem, /* i: dividend, o: remainder */
mp_int *quot) /* i: 0; o: quotient */
{
mp_int part, t;
#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_DIV_WORD)
mp_word q_msd;
#else
mp_digit q_msd;
#endif
mp_err res;
mp_digit d;
mp_digit div_msd;
@ -4215,7 +4212,7 @@ mp_err s_mp_div(mp_int *rem, /* i: dividend, o: remainder */
MP_USED(&part) = MP_USED(div);
/* We have now truncated the part of the remainder to the same length as
* the divisor. If part is smaller than div, extend part by one digit. */
* the divisor. If part is smaller than div, extend part by one digit. */
if (s_mp_cmp(&part, div) < 0) {
--unusedRem;
#if MP_ARGCHK == 2
@ -4232,18 +4229,12 @@ mp_err s_mp_div(mp_int *rem, /* i: dividend, o: remainder */
div_msd = MP_DIGIT(div, MP_USED(div) - 1);
if (!partExtended) {
/* In this case, q_msd /= div_msd is always 1. First, since div_msd is
* normalized to have the high bit set, 2*div_msd > MP_DIGIT_MAX. Since
* we didn't extend part, q_msd >= div_msd. Therefore we know that
* div_msd <= q_msd <= MP_DIGIT_MAX < 2*div_msd. Dividing by div_msd we
* get 1 <= q_msd/div_msd < 2. So q_msd /= div_msd must be 1. */
* normalized to have the high bit set, 2*div_msd > MP_DIGIT_MAX. Since
* we didn't extend part, q_msd >= div_msd. Therefore we know that
* div_msd <= q_msd <= MP_DIGIT_MAX < 2*div_msd. Dividing by div_msd we
* get 1 <= q_msd/div_msd < 2. So q_msd /= div_msd must be 1. */
q_msd = 1;
} else {
#if !defined(MP_NO_MP_WORD) && !defined(MP_NO_DIV_WORD)
q_msd = (q_msd << MP_DIGIT_BIT) | MP_DIGIT(&part, MP_USED(&part) - 2);
q_msd /= div_msd;
if (q_msd == RADIX)
--q_msd;
#else
if (q_msd == div_msd) {
q_msd = MP_DIGIT_MAX;
} else {
@ -4251,7 +4242,6 @@ mp_err s_mp_div(mp_int *rem, /* i: dividend, o: remainder */
MP_CHECKOK(s_mpv_div_2dx1d(q_msd, MP_DIGIT(&part, MP_USED(&part) - 2),
div_msd, &q_msd, &r));
}
#endif
}
#if MP_ARGCHK == 2
assert(q_msd > 0); /* This case should never occur any more. */
@ -4261,15 +4251,15 @@ mp_err s_mp_div(mp_int *rem, /* i: dividend, o: remainder */
/* See what that multiplies out to */
mp_copy(div, &t);
MP_CHECKOK(s_mp_mul_d(&t, (mp_digit)q_msd));
MP_CHECKOK(s_mp_mul_d(&t, q_msd));
/*
If it's too big, back it off. We should not have to do this
more than once, or, in rare cases, twice. Knuth describes a
method by which this could be reduced to a maximum of once, but
I didn't implement that here.
* When using s_mpv_div_2dx1d, we may have to do this 3 times.
*/
If it's too big, back it off. We should not have to do this
more than once, or, in rare cases, twice. Knuth describes a
method by which this could be reduced to a maximum of once, but
I didn't implement that here.
When using s_mpv_div_2dx1d, we may have to do this 3 times.
*/
for (i = 4; s_mp_cmp(&t, &part) > 0 && i > 0; --i) {
--q_msd;
MP_CHECKOK(s_mp_sub(&t, div)); /* t -= div */
@ -4284,11 +4274,11 @@ mp_err s_mp_div(mp_int *rem, /* i: dividend, o: remainder */
s_mp_clamp(rem);
/*
Include the digit in the quotient. We allocated enough memory
for any quotient we could ever possibly get, so we should not
have to check for failures here
*/
MP_DIGIT(quot, unusedRem) = (mp_digit)q_msd;
Include the digit in the quotient. We allocated enough memory
for any quotient we could ever possibly get, so we should not
have to check for failures here
*/
MP_DIGIT(quot, unusedRem) = q_msd;
}
/* Denormalize remainder */

2
security/nss/lib/freebl/mpi/mpi.h
View file

@ -225,13 +225,11 @@ int mp_isodd(const mp_int *a);
int mp_iseven(const mp_int *a);
/* Number theoretic */
#if MP_NUMTH
mp_err mp_gcd(mp_int *a, mp_int *b, mp_int *c);
mp_err mp_lcm(mp_int *a, mp_int *b, mp_int *c);
mp_err mp_xgcd(const mp_int *a, const mp_int *b, mp_int *g, mp_int *x, mp_int *y);
mp_err mp_invmod(const mp_int *a, const mp_int *m, mp_int *c);
mp_err mp_invmod_xgcd(const mp_int *a, const mp_int *m, mp_int *c);
#endif /* end MP_NUMTH */
/* Input and output */
#if MP_IOFUNC

6
security/nss/lib/freebl/mpi/mpmontg.c
View file

@ -205,7 +205,11 @@ mp_exptmod_f(const mp_int *montBase,
dTmpSize = 2 * oddPowSize;
dSize = sizeof(double) * (nLen * 4 + 1 +
((odd_ints + 1) * oddPowSize) + dTmpSize);
dBuf = (double *)malloc(dSize);
dBuf = malloc(dSize);
if (!dBuf) {
res = MP_MEM;
goto CLEANUP;
}
dm1 = dBuf; /* array of d32 */
dn = dBuf + nLen; /* array of d32 */
dSqr = dn + nLen; /* array of d32 */

5
security/nss/lib/freebl/mpi/mpprime.c
View file

@ -402,8 +402,7 @@ mpp_sieve(mp_int *trial, const mp_digit *primes, mp_size nPrimes,
#define SIEVE_SIZE 32 * 1024
mp_err
mpp_make_prime(mp_int *start, mp_size nBits, mp_size strong,
unsigned long *nTries)
mpp_make_prime(mp_int *start, mp_size nBits, mp_size strong)
{
mp_digit np;
mp_err res;
@ -548,8 +547,6 @@ mpp_make_prime(mp_int *start, mp_size nBits, mp_size strong,
CLEANUP:
mp_clear(&trial);
mp_clear(&q);
if (nTries)
*nTries += i;
if (sieve != NULL) {
memset(sieve, 0, SIEVE_SIZE);
free(sieve);

7
security/nss/lib/freebl/mpi/mpprime.h
View file

@ -13,6 +13,8 @@
#include "mpi.h"
SEC_BEGIN_PROTOS
extern const int prime_tab_size; /* number of primes available */
extern const mp_digit prime_tab[];
@ -32,7 +34,8 @@ mp_err mpp_fermat_list(mp_int *a, const mp_digit *primes, mp_size nPrimes);
mp_err mpp_pprime(mp_int *a, int nt);
mp_err mpp_sieve(mp_int *trial, const mp_digit *primes, mp_size nPrimes,
unsigned char *sieve, mp_size nSieve);
mp_err mpp_make_prime(mp_int *start, mp_size nBits, mp_size strong,
unsigned long *nTries);
mp_err mpp_make_prime(mp_int *start, mp_size nBits, mp_size strong);
SEC_END_PROTOS
#endif /* end _H_MP_PRIME_ */

76
security/nss/lib/freebl/mpi/multest
View file

@ -1,76 +0,0 @@
#!/bin/sh
#
# multest
#
# Run multiply and square timing tests, to compute a chart for the
# current processor and compiler combination.
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
ECHO=/bin/echo
MAKE=gmake
$ECHO "\n** Running multiply and square timing tests\n"
$ECHO "Bringing 'mulsqr' up to date ... "
if $MAKE mulsqr ; then
:
else
$ECHO "\nMake failed to build mulsqr.\n"
exit 1
fi
if [ ! -x ./mulsqr ] ; then
$ECHO "\nCannot find 'mulsqr' program, testing cannot continue.\n"
exit 1
fi
sizes='64 128 192 256 320 384 448 512 640 768 896 1024 1536 2048'
ntests=500000
$ECHO "Running timing tests, please wait ... "
trap 'echo "oop!";rm -f tt*.tmp;exit 0' INT HUP
touch tt$$.tmp
$ECHO $ntests tests >> tt$$.tmp
for size in $sizes ; do
$ECHO "$size bits ... \c"
set -A res `./mulsqr $ntests $size|head -3|tr -d '%'|awk '{print $2}'`
$ECHO $size"\t"${res[0]}"\t"${res[1]}"\t"${res[2]} >> tt$$.tmp
$ECHO "(done)"
done
mv tt$$.tmp mulsqr-results.txt
rm -f tt$$.tmp
$ECHO "\n** Running Karatsuba-Ofman multiplication tests\n"
$ECHO "Brining 'karatsuba' up to date ... "
if $MAKE karatsuba ; then
:
else
$ECHO "\nMake failed to build karatsuba.\n"
exit 1
fi
if [ ! -x ./karatsuba ] ; then
$ECHO "\nCannot find 'karatsuba' program, testing cannot continue.\n"
exit 1
fi
ntests=100000
trap 'echo "oop!";rm -f tt*.tmp;exit 0' INT HUP
touch tt$$.tmp
for size in $sizes ; do
$ECHO "$size bits ... "
./karatsuba $ntests $size >> tt$$.tmp
tail -2 tt$$.tmp
done
mv tt$$.tmp karatsuba-results.txt
rm -f tt$$.tmp
exit 0

39
security/nss/lib/freebl/mpi/stats
View file

@ -1,39 +0,0 @@
#!/usr/bin/perl
#
# Treat each line as a sequence of comma and/or space delimited
# floating point numbers, and compute basic statistics on them.
# These are written to standard output
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
$min = 1.7976931348623157E+308;
$max = 2.2250738585072014E-308;
$sum = $num = 0;
while(<>) {
chomp;
@nums = split(/[\s,]+/, $_);
next if($#nums < 0);
$num += scalar @nums;
foreach (@nums) {
$min = $_ if($_ < $min);
$max = $_ if($_ > $max);
$sum += $_;
}
}
if($num) {
$avg = $sum / $num;
} else {
$min = $max = 0;
}
printf "%d\tmin=%.2f, avg=%.2f, max=%.2f, sum=%.2f\n",
$num, $min, $avg, $max, $sum;
# end

233
security/nss/lib/freebl/mpi/target.mk
View file

@ -1,233 +0,0 @@
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
##
## Define CFLAGS to contain any local options your compiler
## setup requires.
##
## Conditional compilation options are no longer here; see
## the file 'mpi-config.h' instead.
##
MPICMN = -I. -DMP_API_COMPATIBLE -DMP_IOFUNC
CFLAGS= -O $(MPICMN)
#CFLAGS=-ansi -fullwarn -woff 1521 -O3 $(MPICMN)
#CFLAGS=-ansi -pedantic -Wall -O3 $(MPICMN)
#CFLAGS=-ansi -pedantic -Wall -g -O2 -DMP_DEBUG=1 $(MPICMN)
ifeq ($(TARGET),mipsIRIX)
#IRIX
#MPICMN += -DMP_MONT_USE_MP_MUL
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE
MPICMN += -DMP_USE_UINT_DIGIT
#MPICMN += -DMP_NO_MP_WORD
AS_OBJS = mpi_mips.o
#ASFLAGS = -O -OPT:Olimit=4000 -dollar -fullwarn -xansi -n32 -mips3 -exceptions
ASFLAGS = -O -OPT:Olimit=4000 -dollar -fullwarn -xansi -n32 -mips3
#CFLAGS=-ansi -n32 -O3 -fullwarn -woff 1429 -D_SGI_SOURCE $(MPICMN)
CFLAGS=-ansi -n32 -O2 -fullwarn -woff 1429 -D_SGI_SOURCE $(MPICMN)
#CFLAGS=-ansi -n32 -g -fullwarn -woff 1429 -D_SGI_SOURCE $(MPICMN)
#CFLAGS=-ansi -64 -O2 -fullwarn -woff 1429 -D_SGI_SOURCE -DMP_NO_MP_WORD \
$(MPICMN)
endif
ifeq ($(TARGET),alphaOSF1)
#Alpha/OSF1
MPICMN += -DMP_ASSEMBLY_MULTIPLY
AS_OBJS+= mpvalpha.o
#CFLAGS= -O -Olimit 4000 -ieee_with_inexact -std1 -DOSF1 -D_REENTRANT $(MPICMN)
CFLAGS= -O -Olimit 4000 -ieee_with_inexact -std1 -DOSF1 -D_REENTRANT \
-DMP_NO_MP_WORD $(MPICMN)
endif
ifeq ($(TARGET),v9SOLARIS)
#Solaris 64
SOLARIS_FPU_FLAGS = -fast -xO5 -xrestrict=%all -xchip=ultra -xarch=v9a -KPIC -mt
#SOLARIS_FPU_FLAGS = -fast -xO5 -xrestrict=%all -xdepend -xchip=ultra -xarch=v9a -KPIC -mt
SOLARIS_ASM_FLAGS = -xchip=ultra -xarch=v9a -KPIC -mt
AS_OBJS += montmulfv9.o
AS_OBJS += mpi_sparc.o mpv_sparcv9.o
MPICMN += -DMP_USE_UINT_DIGIT
#MPICMN += -DMP_NO_MP_WORD
MPICMN += -DMP_ASSEMBLY_MULTIPLY
MPICMN += -DMP_USING_MONT_MULF
CFLAGS= -O -KPIC -DSVR4 -DSYSV -D__svr4 -D__svr4__ -DSOLARIS -D_REENTRANT \
-DSOLARIS2_8 -xarch=v9 -DXP_UNIX $(MPICMN)
#CFLAGS= -g -KPIC -DSVR4 -DSYSV -D__svr4 -D__svr4__ -DSOLARIS -D_REENTRANT \
-DSOLARIS2_8 -xarch=v9 -DXP_UNIX $(MPICMN)
endif
ifeq ($(TARGET),v8plusSOLARIS)
#Solaris 32
SOLARIS_FPU_FLAGS = -fast -xO5 -xrestrict=%all -xdepend -xchip=ultra -xarch=v8plusa -KPIC -mt
SOLARIS_ASM_FLAGS = -xchip=ultra -xarch=v8plusa -KPIC -mt
AS_OBJS += montmulfv8.o
AS_OBJS += mpi_sparc.o mpv_sparcv8.o
#AS_OBJS = montmulf.o
MPICMN += -DMP_ASSEMBLY_MULTIPLY
MPICMN += -DMP_USING_MONT_MULF
MPICMN += -DMP_USE_UINT_DIGIT
MPICMN += -DMP_NO_MP_WORD
CFLAGS=-O -KPIC -DSVR4 -DSYSV -D__svr4 -D__svr4__ -DSOLARIS -D_REENTRANT \
-DSOLARIS2_6 -xarch=v8plus -DXP_UNIX $(MPICMN)
endif
ifeq ($(TARGET),v8SOLARIS)
#Solaris 32
#SOLARIS_FPU_FLAGS = -fast -xO5 -xrestrict=%all -xdepend -xchip=ultra -xarch=v8 -KPIC -mt
#SOLARIS_ASM_FLAGS = -xchip=ultra -xarch=v8plusa -KPIC -mt
#AS_OBJS = montmulfv8.o mpi_sparc.o mpv_sparcv8.o
#AS_OBJS = montmulf.o
#MPICMN += -DMP_USING_MONT_MULF
#MPICMN += -DMP_ASSEMBLY_MULTIPLY
MPICMN += -DMP_USE_LONG_LONG_MULTIPLY -DMP_USE_UINT_DIGIT
MPICMN += -DMP_NO_MP_WORD
CFLAGS=-O -KPIC -DSVR4 -DSYSV -D__svr4 -D__svr4__ -DSOLARIS -D_REENTRANT \
-DSOLARIS2_6 -xarch=v8 -DXP_UNIX $(MPICMN)
endif
ifeq ($(TARGET),ia64HPUX)
#HPUX 32 on ia64 -- 64 bit digits SCREAM.
# This one is for DD32 which is the 32-bit ABI with 64-bit registers.
CFLAGS= +O3 -DHPUX10 -D_POSIX_C_SOURCE=199506L -Aa +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +p +DD32 -DHPUX11 -DXP_UNIX -Wl,+k $(MPICMN)
#CFLAGS= -O -DHPUX10 -D_POSIX_C_SOURCE=199506L -Aa +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +p +DD32 -DHPUX11 -DXP_UNIX -Wl,+k $(MPICMN)
#CFLAGS= -g -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +p +DD32 -DHPUX11 -DXP_UNIX -Wl,+k $(MPICMN)
endif
ifeq ($(TARGET),ia64HPUX64)
#HPUX 32 on ia64
# This one is for DD64 which is the 64-bit ABI
CFLAGS= +O3 -DHPUX10 -D_POSIX_C_SOURCE=199506L -Aa +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +p +DD64 -DHPUX11 -DXP_UNIX -Wl,+k $(MPICMN)
#CFLAGS= -g -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +p +DD64 -DHPUX11 -DXP_UNIX -Wl,+k $(MPICMN)
endif
ifeq ($(TARGET),PA2.0WHPUX)
#HPUX64 (HP PA 2.0 Wide) using MAXPY and 64-bit digits
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE
AS_OBJS = mpi_hp.o hpma512.o hppa20.o
CFLAGS= -O -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +DA2.0W +DS2.0 +O3 +DChpux -DHPUX11 -DXP_UNIX \
$(MPICMN)
#CFLAGS= -g -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +DA2.0W +DS2.0 +DChpux -DHPUX11 -DXP_UNIX \
$(MPICMN)
AS = $(CC) $(CFLAGS) -c
endif
ifeq ($(TARGET),PA2.0NHPUX)
#HPUX32 (HP PA 2.0 Narrow) hybrid model, using 32-bit digits
# This one is for DA2.0 (N) which is the 32-bit ABI with 64-bit registers.
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE
AS_OBJS = mpi_hp.o hpma512.o hppa20.o
CFLAGS= +O3 -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +DA2.0 +DS2.0 +DChpux -DHPUX11 -DXP_UNIX \
-Wl,+k $(MPICMN)
#CFLAGS= -g -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE -Aa +e -z +DA2.0 +DS2.0 +DChpux -DHPUX11 -DXP_UNIX \
-Wl,+k $(MPICMN)
AS = $(CC) $(CFLAGS) -c
endif
ifeq ($(TARGET),PA1.1HPUX)
#HPUX32 (HP PA 1.1) Pure 32 bit
MPICMN += -DMP_USE_UINT_DIGIT -DMP_NO_MP_WORD
#MPICMN += -DMP_USE_LONG_LONG_MULTIPLY
CFLAGS= -O -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
-D_HPUX_SOURCE +DAportable +DS1.1 -DHPUX11 -DXP_UNIX $(MPICMN)
##CFLAGS= -g -DHPUX10 -D_POSIX_C_SOURCE=199506L -Ae +Z -DHPUX -Dhppa \
# -D_HPUX_SOURCE +DAportable +DS1.1 -DHPUX11 -DXP_UNIX $(MPICMN)
endif
ifeq ($(TARGET),32AIX)
#
CC = xlC_r
MPICMN += -DMP_USE_UINT_DIGIT
MPICMN += -DMP_NO_DIV_WORD
#MPICMN += -DMP_NO_MUL_WORD
MPICMN += -DMP_NO_ADD_WORD
MPICMN += -DMP_NO_SUB_WORD
#MPICMN += -DMP_NO_MP_WORD
#MPICMN += -DMP_USE_LONG_LONG_MULTIPLY
CFLAGS = -O -DAIX -DSYSV -qarch=com -DAIX4_3 -DXP_UNIX -UDEBUG -DNDEBUG $(MPICMN)
#CFLAGS = -g -DAIX -DSYSV -qarch=com -DAIX4_3 -DXP_UNIX -UDEBUG -DNDEBUG $(MPICMN)
#CFLAGS += -pg
endif
ifeq ($(TARGET),64AIX)
#
CC = xlC_r
MPICMN += -DMP_USE_UINT_DIGIT
CFLAGS = -O -O2 -DAIX -DSYSV -qarch=com -DAIX_64BIT -DAIX4_3 -DXP_UNIX -UDEBUG -DNDEBUG $(MPICMN)
OBJECT_MODE=64
export OBJECT_MODE
endif
ifeq ($(TARGET),x86LINUX)
#Linux
AS_OBJS = mpi_x86.o
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE -DMP_ASSEMBLY_DIV_2DX1D
MPICMN += -DMP_MONT_USE_MP_MUL -DMP_IS_LITTLE_ENDIAN
CFLAGS= -O2 -fPIC -DLINUX1_2 -Di386 -D_XOPEN_SOURCE -DLINUX2_1 -ansi -Wall \
-pipe -DLINUX -Dlinux -D_POSIX_SOURCE -D_BSD_SOURCE -DHAVE_STRERROR \
-DXP_UNIX -UDEBUG -DNDEBUG -D_REENTRANT $(MPICMN)
#CFLAGS= -g -fPIC -DLINUX1_2 -Di386 -D_XOPEN_SOURCE -DLINUX2_1 -ansi -Wall \
-pipe -DLINUX -Dlinux -D_POSIX_SOURCE -D_BSD_SOURCE -DHAVE_STRERROR \
-DXP_UNIX -DDEBUG -UNDEBUG -D_REENTRANT $(MPICMN)
#CFLAGS= -g -fPIC -DLINUX1_2 -Di386 -D_XOPEN_SOURCE -DLINUX2_1 -ansi -Wall \
-pipe -DLINUX -Dlinux -D_POSIX_SOURCE -D_BSD_SOURCE -DHAVE_STRERROR \
-DXP_UNIX -UDEBUG -DNDEBUG -D_REENTRANT $(MPICMN)
endif
ifeq ($(TARGET),armLINUX)
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE
MPICMN += -DMP_USE_UINT_DIGIT
AS_OBJS += mpi_arm.o
endif
ifeq ($(TARGET),AMD64SOLARIS)
ASFLAGS += -xarch=generic64
AS_OBJS = mpi_amd64.o mpi_amd64_sun.o
MP_CONFIG = -DMP_ASSEMBLY_MULTIPLY -DMPI_AMD64
MP_CONFIG += -DMP_IS_LITTLE_ENDIAN
CFLAGS = -xarch=generic64 -xO4 -I. -DMP_API_COMPATIBLE -DMP_IOFUNC $(MP_CONFIG)
MPICMN += $(MP_CONFIG)
mpi_amd64_asm.o: mpi_amd64_sun.s
$(AS) -xarch=generic64 -P -D_ASM mpi_amd64_sun.s
endif
ifeq ($(TARGET),WIN32)
ifeq ($(CPU_ARCH),x86_64)
AS_OBJS = mpi_amd64.obj mpi_amd64_masm.obj mp_comba_amd64_masm.asm
CFLAGS = -Od -Z7 -MDd -W3 -nologo -DDEBUG -D_DEBUG -UNDEBUG -DDEBUG_$(USER)
CFLAGS += -DWIN32 -DWIN64 -D_WINDOWS -D_AMD_64_ -D_M_AMD64 -DWIN95 -DXP_PC
CFLAGS += $(MPICMN)
$(AS_OBJS): %.obj : %.asm
ml64 -Cp -Sn -Zi -coff -nologo -c $<
$(LIBOBJS): %.obj : %.c
cl $(CFLAGS) -Fo$@ -c $<
else
AS_OBJS = mpi_x86.obj
MPICMN += -DMP_ASSEMBLY_MULTIPLY -DMP_ASSEMBLY_SQUARE -DMP_ASSEMBLY_DIV_2DX1D
MPICMN += -DMP_USE_UINT_DIGIT -DMP_NO_MP_WORD -DMP_API_COMPATIBLE
MPICMN += -DMP_MONT_USE_MP_MUL
MPICMN += -DMP_CHAR_STORE_SLOW -DMP_IS_LITTLE_ENDIAN
CFLAGS = -Od -Z7 -MDd -W3 -nologo -DDEBUG -D_DEBUG -UNDEBUG -DDEBUG_$(USER)
CFLAGS += -DWIN32 -D_WINDOWS -D_X86_ -DWIN95 -DXP_PC
CFLAGS += $(MPICMN)
$(AS_OBJS): %.obj : %.asm
ml -Cp -Sn -Zi -coff -nologo -c $<
$(LIBOBJS): %.obj : %.c
cl $(CFLAGS) -Fo$@ -c $<
endif
endif

55
security/nss/lib/freebl/mpi/test-arrays.txt
View file

@ -1,55 +0,0 @@
#
# Test suite table for MPI library
#
# Format of entries:
# suite-name:function-name:description
#
# suite-name The name used to identify this test in mpi-test
# function-name The function called to perform this test in mpi-test.c
# description A brief description of what the suite tests
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
list:test_list:print out a list of the available test suites
copy:test_copy:test assignment of mp-int structures
exchange:test_exch:test exchange of mp-int structures
zero:test_zero:test zeroing of an mp-int
set:test_set:test setting an mp-int to a small constant
absolute-value:test_abs:test the absolute value function
negate:test_neg:test the arithmetic negation function
add-digit:test_add_d:test digit addition
add:test_add:test full addition
subtract-digit:test_sub_d:test digit subtraction
subtract:test_sub:test full subtraction
multiply-digit:test_mul_d:test digit multiplication
multiply:test_mul:test full multiplication
square:test_sqr:test full squaring function
divide-digit:test_div_d:test digit division
divide-2:test_div_2:test division by two
divide-2d:test_div_2d:test division & remainder by 2^d
divide:test_div:test full division
expt-digit:test_expt_d:test digit exponentiation
expt:test_expt:test full exponentiation
expt-2:test_2expt:test power-of-two exponentiation
modulo-digit:test_mod_d:test digit modular reduction
modulo:test_mod:test full modular reduction
mod-add:test_addmod:test modular addition
mod-subtract:test_submod:test modular subtraction
mod-multiply:test_mulmod:test modular multiplication
mod-square:test_sqrmod:test modular squaring function
mod-expt:test_exptmod:test full modular exponentiation
mod-expt-digit:test_exptmod_d:test digit modular exponentiation
mod-inverse:test_invmod:test modular inverse function
compare-digit:test_cmp_d:test digit comparison function
compare-zero:test_cmp_z:test zero comparison function
compare:test_cmp:test general signed comparison
compare-magnitude:test_cmp_mag:test general magnitude comparison
parity:test_parity:test parity comparison functions
gcd:test_gcd:test greatest common divisor functions
lcm:test_lcm:test least common multiple function
conversion:test_convert:test general radix conversion facilities
binary:test_raw:test raw output format
pprime:test_pprime:test probabilistic primality tester
fermat:test_fermat:test Fermat pseudoprimality tester

6
security/nss/lib/freebl/mpi/tests/LICENSE
View file

@ -1,6 +0,0 @@
Within this directory, each of the file listed below is licensed under
the terms given in the file LICENSE-MPL, also in this directory.
pi1k.txt
pi2k.txt
pi5k.txt

3
security/nss/lib/freebl/mpi/tests/LICENSE-MPL
View file

@ -1,3 +0,0 @@
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.

43
security/nss/lib/freebl/mpi/tests/mptest-1.c
View file

@ -1,43 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 1: Simple input test (drives single-digit multiply and add,
* as well as I/O routines)
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#ifdef MAC_CW_SIOUX
#include <console.h>
#endif
#include "mpi.h"
int
main(int argc, char *argv[])
{
int ix;
mp_int mp;
#ifdef MAC_CW_SIOUX
argc = ccommand(&argv);
#endif
mp_init(&mp);
for (ix = 1; ix < argc; ix++) {
mp_read_radix(&mp, argv[ix], 10);
mp_print(&mp, stdout);
fputc('\n', stdout);
}
mp_clear(&mp);
return 0;
}

62
security/nss/lib/freebl/mpi/tests/mptest-2.c
View file

@ -1,62 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 2: Basic addition and subtraction test
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
mp_int a, b, c;
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]);
return 1;
}
printf("Test 2: Basic addition and subtraction\n\n");
mp_init(&a);
mp_init(&b);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&b, argv[2], 10);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
mp_init(&c);
printf("c = a + b\n");
mp_add(&a, &b, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("c = a - b\n");
mp_sub(&a, &b, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mp_clear(&c);
mp_clear(&b);
mp_clear(&a);
return 0;
}

105
security/nss/lib/freebl/mpi/tests/mptest-3.c
View file

@ -1,105 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 3: Multiplication, division, and exponentiation test
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#include "mpi.h"
#define EXPT 0 /* define nonzero to get exponentiate test */
int
main(int argc, char *argv[])
{
int ix;
mp_int a, b, c, d;
mp_digit r;
mp_err res;
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]);
return 1;
}
printf("Test 3: Multiplication and division\n\n");
srand(time(NULL));
mp_init(&a);
mp_init(&b);
mp_read_variable_radix(&a, argv[1], 10);
mp_read_variable_radix(&b, argv[2], 10);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
mp_init(&c);
printf("\nc = a * b\n");
mp_mul(&a, &b, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nc = b * 32523\n");
mp_mul_d(&b, 32523, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mp_init(&d);
printf("\nc = a / b, d = a mod b\n");
mp_div(&a, &b, &c, &d);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("d = ");
mp_print(&d, stdout);
fputc('\n', stdout);
ix = rand() % 256;
printf("\nc = a / %d, r = a mod %d\n", ix, ix);
mp_div_d(&a, (mp_digit)ix, &c, &r);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("r = %04X\n", r);
#if EXPT
printf("\nc = a ** b\n");
mp_expt(&a, &b, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
#endif
ix = rand() % 256;
printf("\nc = 2^%d\n", ix);
mp_2expt(&c, ix);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mp_clear(&d);
mp_clear(&c);
mp_clear(&b);
mp_clear(&a);
return 0;
}

123
security/nss/lib/freebl/mpi/tests/mptest-3a.c
View file

@ -1,123 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 3a: Multiplication vs. squaring timing test
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#include "mpi.h"
#include "mpprime.h"
int
main(int argc, char *argv[])
{
int ix, num, prec = 8;
double d1, d2;
clock_t start, finish;
time_t seed;
mp_int a, c, d;
seed = time(NULL);
if (argc < 2) {
fprintf(stderr, "Usage: %s <num-tests> [<precision>]\n", argv[0]);
return 1;
}
if ((num = atoi(argv[1])) < 0)
num = -num;
if (!num) {
fprintf(stderr, "%s: must perform at least 1 test\n", argv[0]);
return 1;
}
if (argc > 2) {
if ((prec = atoi(argv[2])) <= 0)
prec = 8;
else
prec = (prec + (DIGIT_BIT - 1)) / DIGIT_BIT;
}
printf("Test 3a: Multiplication vs squaring timing test\n"
"Precision: %d digits (%u bits)\n"
"# of tests: %d\n\n",
prec, prec * DIGIT_BIT, num);
mp_init_size(&a, prec);
mp_init(&c);
mp_init(&d);
printf("Verifying accuracy ... \n");
srand((unsigned int)seed);
for (ix = 0; ix < num; ix++) {
mpp_random_size(&a, prec);
mp_mul(&a, &a, &c);
mp_sqr(&a, &d);
if (mp_cmp(&c, &d) != 0) {
printf("Error! Results not accurate:\n");
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("d = ");
mp_print(&d, stdout);
fputc('\n', stdout);
mp_sub(&c, &d, &d);
printf("dif ");
mp_print(&d, stdout);
fputc('\n', stdout);
mp_clear(&c);
mp_clear(&d);
mp_clear(&a);
return 1;
}
}
printf("Accuracy is confirmed for the %d test samples\n", num);
mp_clear(&d);
printf("Testing squaring ... \n");
srand((unsigned int)seed);
start = clock();
for (ix = 0; ix < num; ix++) {
mpp_random_size(&a, prec);
mp_sqr(&a, &c);
}
finish = clock();
d2 = (double)(finish - start) / CLOCKS_PER_SEC;
printf("Testing multiplication ... \n");
srand((unsigned int)seed);
start = clock();
for (ix = 0; ix < num; ix++) {
mpp_random(&a);
mp_mul(&a, &a, &c);
}
finish = clock();
d1 = (double)(finish - start) / CLOCKS_PER_SEC;
printf("Multiplication time: %.3f sec (%.3f each)\n", d1, d1 / num);
printf("Squaring time: %.3f sec (%.3f each)\n", d2, d2 / num);
printf("Improvement: %.2f%%\n", (1.0 - (d2 / d1)) * 100.0);
mp_clear(&c);
mp_clear(&a);
return 0;
}

111
security/nss/lib/freebl/mpi/tests/mptest-4.c
View file

@ -1,111 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 4: Modular arithmetic tests
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
int ix;
mp_int a, b, c, m;
mp_digit r;
if (argc < 4) {
fprintf(stderr, "Usage: %s <a> <b> <m>\n", argv[0]);
return 1;
}
printf("Test 4: Modular arithmetic\n\n");
mp_init(&a);
mp_init(&b);
mp_init(&m);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&b, argv[2], 10);
mp_read_radix(&m, argv[3], 10);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("m = ");
mp_print(&m, stdout);
fputc('\n', stdout);
mp_init(&c);
printf("\nc = a (mod m)\n");
mp_mod(&a, &m, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nc = b (mod m)\n");
mp_mod(&b, &m, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nc = b (mod 1853)\n");
mp_mod_d(&b, 1853, &r);
printf("c = %04X\n", r);
printf("\nc = (a + b) mod m\n");
mp_addmod(&a, &b, &m, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nc = (a - b) mod m\n");
mp_submod(&a, &b, &m, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nc = (a * b) mod m\n");
mp_mulmod(&a, &b, &m, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nc = (a ** b) mod m\n");
mp_exptmod(&a, &b, &m, &c);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("\nIn-place modular squaring test:\n");
for (ix = 0; ix < 5; ix++) {
printf("a = (a * a) mod m a = ");
mp_sqrmod(&a, &m, &a);
mp_print(&a, stdout);
fputc('\n', stdout);
}
mp_clear(&c);
mp_clear(&m);
mp_clear(&b);
mp_clear(&a);
return 0;
}

109
security/nss/lib/freebl/mpi/tests/mptest-4a.c
View file

@ -1,109 +0,0 @@
/*
* mptest4a - modular exponentiation speed test
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <time.h>
#include <sys/time.h>
#include "mpi.h"
#include "mpprime.h"
typedef struct {
unsigned int sec;
unsigned int usec;
} instant_t;
instant_t
now(void)
{
struct timeval clk;
instant_t res;
res.sec = res.usec = 0;
if (gettimeofday(&clk, NULL) != 0)
return res;
res.sec = clk.tv_sec;
res.usec = clk.tv_usec;
return res;
}
extern mp_err s_mp_pad();
int
main(int argc, char *argv[])
{
int ix, num, prec = 8;
unsigned int d;
instant_t start, finish;
time_t seed;
mp_int a, m, c;
seed = time(NULL);
if (argc < 2) {
fprintf(stderr, "Usage: %s <num-tests> [<precision>]\n", argv[0]);
return 1;
}
if ((num = atoi(argv[1])) < 0)
num = -num;
if (!num) {
fprintf(stderr, "%s: must perform at least 1 test\n", argv[0]);
return 1;
}
if (argc > 2) {
if ((prec = atoi(argv[2])) <= 0)
prec = 8;
}
printf("Test 3a: Modular exponentiation timing test\n"
"Precision: %d digits (%d bits)\n"
"# of tests: %d\n\n",
prec, prec * DIGIT_BIT, num);
mp_init_size(&a, prec);
mp_init_size(&m, prec);
mp_init_size(&c, prec);
s_mp_pad(&a, prec);
s_mp_pad(&m, prec);
s_mp_pad(&c, prec);
printf("Testing modular exponentiation ... \n");
srand((unsigned int)seed);
start = now();
for (ix = 0; ix < num; ix++) {
mpp_random(&a);
mpp_random(&c);
mpp_random(&m);
mp_exptmod(&a, &c, &m, &c);
}
finish = now();
d = (finish.sec - start.sec) * 1000000;
d -= start.usec;
d += finish.usec;
printf("Total time elapsed: %u usec\n", d);
printf("Time per exponentiation: %u usec (%.3f sec)\n",
(d / num), (double)(d / num) / 1000000);
mp_clear(&c);
mp_clear(&a);
mp_clear(&m);
return 0;
}

107
security/nss/lib/freebl/mpi/tests/mptest-4b.c
View file

@ -1,107 +0,0 @@
/*
* mptest-4b.c
*
* Test speed of a large modular exponentiation of a primitive element
* modulo a prime.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <time.h>
#include <sys/time.h>
#include "mpi.h"
#include "mpprime.h"
char *g_prime =
"34BD53C07350E817CCD49721020F1754527959C421C1533244769D4CF060A8B1C3DA"
"25094BE723FB1E2369B55FEEBBE0FAC16425161BF82684062B5EC5D7D47D1B23C117"
"0FA19745E44A55E148314E582EB813AC9EE5126295E2E380CACC2F6D206B293E5ED9"
"23B54EE961A8C69CD625CE4EC38B70C649D7F014432AEF3A1C93";
char *g_gen = "5";
typedef struct {
unsigned int sec;
unsigned int usec;
} instant_t;
instant_t
now(void)
{
struct timeval clk;
instant_t res;
res.sec = res.usec = 0;
if (gettimeofday(&clk, NULL) != 0)
return res;
res.sec = clk.tv_sec;
res.usec = clk.tv_usec;
return res;
}
extern mp_err s_mp_pad();
int
main(int argc, char *argv[])
{
instant_t start, finish;
mp_int prime, gen, expt, res;
unsigned int ix, diff;
int num;
srand(time(NULL));
if (argc < 2) {
fprintf(stderr, "Usage: %s <num-tests>\n", argv[0]);
return 1;
}
if ((num = atoi(argv[1])) < 0)
num = -num;
if (num == 0)
++num;
mp_init(&prime);
mp_init(&gen);
mp_init(&res);
mp_read_radix(&prime, g_prime, 16);
mp_read_radix(&gen, g_gen, 16);
mp_init_size(&expt, USED(&prime) - 1);
s_mp_pad(&expt, USED(&prime) - 1);
printf("Testing %d modular exponentations ... \n", num);
start = now();
for (ix = 0; ix < num; ix++) {
mpp_random(&expt);
mp_exptmod(&gen, &expt, &prime, &res);
}
finish = now();
diff = (finish.sec - start.sec) * 1000000;
diff += finish.usec;
diff -= start.usec;
printf("%d operations took %u usec (%.3f sec)\n",
num, diff, (double)diff / 1000000.0);
printf("That is %.3f sec per operation.\n",
((double)diff / 1000000.0) / num);
mp_clear(&expt);
mp_clear(&res);
mp_clear(&gen);
mp_clear(&prime);
return 0;
}

85
security/nss/lib/freebl/mpi/tests/mptest-5.c
View file

@ -1,85 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 5: Other number theoretic functions
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
mp_int a, b, c, x, y;
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]);
return 1;
}
printf("Test 5: Number theoretic functions\n\n");
mp_init(&a);
mp_init(&b);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&b, argv[2], 10);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
mp_init(&c);
printf("\nc = (a, b)\n");
mp_gcd(&a, &b, &c);
printf("Euclid: c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
/*
mp_bgcd(&a, &b, &c);
printf("Binary: c = "); mp_print(&c, stdout); fputc('\n', stdout);
*/
mp_init(&x);
mp_init(&y);
printf("\nc = (a, b) = ax + by\n");
mp_xgcd(&a, &b, &c, &x, &y);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("x = ");
mp_print(&x, stdout);
fputc('\n', stdout);
printf("y = ");
mp_print(&y, stdout);
fputc('\n', stdout);
printf("\nc = a^-1 (mod b)\n");
if (mp_invmod(&a, &b, &c) == MP_UNDEF) {
printf("a has no inverse mod b\n");
} else {
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
}
mp_clear(&y);
mp_clear(&x);
mp_clear(&c);
mp_clear(&b);
mp_clear(&a);
return 0;
}

147
security/nss/lib/freebl/mpi/tests/mptest-5a.c
View file

@ -1,147 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 5a: Greatest common divisor speed test, binary vs. Euclid
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#include <sys/time.h>
#include "mpi.h"
#include "mpprime.h"
typedef struct {
unsigned int sec;
unsigned int usec;
} instant_t;
instant_t
now(void)
{
struct timeval clk;
instant_t res;
res.sec = res.usec = 0;
if (gettimeofday(&clk, NULL) != 0)
return res;
res.sec = clk.tv_sec;
res.usec = clk.tv_usec;
return res;
}
#define PRECISION 16
int
main(int argc, char *argv[])
{
int ix, num, prec = PRECISION;
mp_int a, b, c, d;
instant_t start, finish;
time_t seed;
unsigned int d1, d2;
seed = time(NULL);
if (argc < 2) {
fprintf(stderr, "Usage: %s <num-tests>\n", argv[0]);
return 1;
}
if ((num = atoi(argv[1])) < 0)
num = -num;
printf("Test 5a: Euclid vs. Binary, a GCD speed test\n\n"
"Number of tests: %d\n"
"Precision: %d digits\n\n",
num, prec);
mp_init_size(&a, prec);
mp_init_size(&b, prec);
mp_init(&c);
mp_init(&d);
printf("Verifying accuracy ... \n");
srand((unsigned int)seed);
for (ix = 0; ix < num; ix++) {
mpp_random_size(&a, prec);
mpp_random_size(&b, prec);
mp_gcd(&a, &b, &c);
mp_bgcd(&a, &b, &d);
if (mp_cmp(&c, &d) != 0) {
printf("Error! Results not accurate:\n");
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("d = ");
mp_print(&d, stdout);
fputc('\n', stdout);
mp_clear(&a);
mp_clear(&b);
mp_clear(&c);
mp_clear(&d);
return 1;
}
}
mp_clear(&d);
printf("Accuracy confirmed for the %d test samples\n", num);
printf("Testing Euclid ... \n");
srand((unsigned int)seed);
start = now();
for (ix = 0; ix < num; ix++) {
mpp_random_size(&a, prec);
mpp_random_size(&b, prec);
mp_gcd(&a, &b, &c);
}
finish = now();
d1 = (finish.sec - start.sec) * 1000000;
d1 -= start.usec;
d1 += finish.usec;
printf("Testing binary ... \n");
srand((unsigned int)seed);
start = now();
for (ix = 0; ix < num; ix++) {
mpp_random_size(&a, prec);
mpp_random_size(&b, prec);
mp_bgcd(&a, &b, &c);
}
finish = now();
d2 = (finish.sec - start.sec) * 1000000;
d2 -= start.usec;
d2 += finish.usec;
printf("Euclidean algorithm time: %u usec\n", d1);
printf("Binary algorithm time: %u usec\n", d2);
printf("Improvement: %.2f%%\n",
(1.0 - ((double)d2 / (double)d1)) * 100.0);
mp_clear(&c);
mp_clear(&b);
mp_clear(&a);
return 0;
}

78
security/nss/lib/freebl/mpi/tests/mptest-6.c
View file

@ -1,78 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 6: Output functions
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "mpi.h"
void
print_buf(FILE *ofp, char *buf, int len)
{
int ix, brk = 0;
for (ix = 0; ix < len; ix++) {
fprintf(ofp, "%02X ", buf[ix]);
brk = (brk + 1) & 0xF;
if (!brk)
fputc('\n', ofp);
}
if (brk)
fputc('\n', ofp);
}
int
main(int argc, char *argv[])
{
int ix, size;
mp_int a;
char *buf;
if (argc < 2) {
fprintf(stderr, "Usage: %s <a>\n", argv[0]);
return 1;
}
printf("Test 6: Output functions\n\n");
mp_init(&a);
mp_read_radix(&a, argv[1], 10);
printf("\nConverting to a string:\n");
printf("Rx Size Representation\n");
for (ix = 2; ix <= MAX_RADIX; ix++) {
size = mp_radix_size(&a, ix);
buf = calloc(size, sizeof(char));
mp_toradix(&a, buf, ix);
printf("%2d: %3d: %s\n", ix, size, buf);
free(buf);
}
printf("\nRaw output:\n");
size = mp_raw_size(&a);
buf = calloc(size, sizeof(char));
printf("Size: %d bytes\n", size);
mp_toraw(&a, buf);
print_buf(stdout, buf, size);
free(buf);
mp_clear(&a);
return 0;
}

85
security/nss/lib/freebl/mpi/tests/mptest-7.c
View file

@ -1,85 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 7: Random and divisibility tests
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#define MP_IOFUNC 1
#include "mpi.h"
#include "mpprime.h"
int
main(int argc, char *argv[])
{
mp_digit num;
mp_int a, b;
srand(time(NULL));
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]);
return 1;
}
printf("Test 7: Random & divisibility tests\n\n");
mp_init(&a);
mp_init(&b);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&b, argv[2], 10);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
if (mpp_divis(&a, &b) == MP_YES)
printf("a is divisible by b\n");
else
printf("a is not divisible by b\n");
if (mpp_divis(&b, &a) == MP_YES)
printf("b is divisible by a\n");
else
printf("b is not divisible by a\n");
printf("\nb = mpp_random()\n");
mpp_random(&b);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
mpp_random(&b);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
mpp_random(&b);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("\nTesting a for divisibility by first 170 primes\n");
num = 170;
if (mpp_divis_primes(&a, &num) == MP_YES)
printf("It is divisible by at least one of them\n");
else
printf("It is not divisible by any of them\n");
mp_clear(&b);
mp_clear(&a);
return 0;
}

68
security/nss/lib/freebl/mpi/tests/mptest-8.c
View file

@ -1,68 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test 8: Probabilistic primality tester
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#define MP_IOFUNC 1
#include "mpi.h"
#include "mpprime.h"
int
main(int argc, char *argv[])
{
int ix;
mp_digit num;
mp_int a;
srand(time(NULL));
if (argc < 2) {
fprintf(stderr, "Usage: %s <a>\n", argv[0]);
return 1;
}
printf("Test 8: Probabilistic primality testing\n\n");
mp_init(&a);
mp_read_radix(&a, argv[1], 10);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("\nChecking for divisibility by small primes ... \n");
num = 170;
if (mpp_divis_primes(&a, &num) == MP_YES) {
printf("it is not prime\n");
goto CLEANUP;
}
printf("Passed that test (not divisible by any small primes).\n");
for (ix = 0; ix < 10; ix++) {
printf("\nPerforming Rabin-Miller test, iteration %d\n", ix + 1);
if (mpp_pprime(&a, 5) == MP_NO) {
printf("it is not prime\n");
goto CLEANUP;
}
}
printf("All tests passed; a is probably prime\n");
CLEANUP:
mp_clear(&a);
return 0;
}

109
security/nss/lib/freebl/mpi/tests/mptest-9.c
View file

@ -1,109 +0,0 @@
/*
* mptest-9.c
*
* Test logical functions
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <time.h>
#include "mpi.h"
#include "mplogic.h"
int
main(int argc, char *argv[])
{
mp_int a, b, c;
int pco;
mp_err res;
printf("Test 9: Logical functions\n\n");
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_init(&b);
mp_init(&c);
mp_read_radix(&a, argv[1], 16);
mp_read_radix(&b, argv[2], 16);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
mpl_not(&a, &c);
printf("~a = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_and(&a, &b, &c);
printf("a & b = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_or(&a, &b, &c);
printf("a | b = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_xor(&a, &b, &c);
printf("a ^ b = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_rsh(&a, &c, 1);
printf("a >> 1 = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_rsh(&a, &c, 5);
printf("a >> 5 = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_rsh(&a, &c, 16);
printf("a >> 16 = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_lsh(&a, &c, 1);
printf("a << 1 = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_lsh(&a, &c, 5);
printf("a << 5 = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_lsh(&a, &c, 16);
printf("a << 16 = ");
mp_print(&c, stdout);
fputc('\n', stdout);
mpl_num_set(&a, &pco);
printf("population(a) = %d\n", pco);
mpl_num_set(&b, &pco);
printf("population(b) = %d\n", pco);
res = mpl_parity(&a);
if (res == MP_EVEN)
printf("a has even parity\n");
else
printf("a has odd parity\n");
mp_clear(&c);
mp_clear(&b);
mp_clear(&a);
return 0;
}

230
security/nss/lib/freebl/mpi/tests/mptest-b.c
View file

@ -1,230 +0,0 @@
/*
* Simple test driver for MPI library
*
* Test GF2m: Binary Polynomial Arithmetic
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "mp_gf2m.h"
int
main(int argc, char *argv[])
{
int ix;
mp_int pp, a, b, x, y, order;
mp_int c, d, e;
mp_digit r;
mp_err res;
unsigned int p[] = { 163, 7, 6, 3, 0 };
unsigned int ptemp[10];
printf("Test b: Binary Polynomial Arithmetic\n\n");
mp_init(&pp);
mp_init(&a);
mp_init(&b);
mp_init(&x);
mp_init(&y);
mp_init(&order);
mp_read_radix(&pp, "0800000000000000000000000000000000000000C9", 16);
mp_read_radix(&a, "1", 16);
mp_read_radix(&b, "020A601907B8C953CA1481EB10512F78744A3205FD", 16);
mp_read_radix(&x, "03F0EBA16286A2D57EA0991168D4994637E8343E36", 16);
mp_read_radix(&y, "00D51FBC6C71A0094FA2CDD545B11C5C0C797324F1", 16);
mp_read_radix(&order, "040000000000000000000292FE77E70C12A4234C33", 16);
printf("pp = ");
mp_print(&pp, stdout);
fputc('\n', stdout);
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("x = ");
mp_print(&x, stdout);
fputc('\n', stdout);
printf("y = ");
mp_print(&y, stdout);
fputc('\n', stdout);
printf("order = ");
mp_print(&order, stdout);
fputc('\n', stdout);
mp_init(&c);
mp_init(&d);
mp_init(&e);
/* Test polynomial conversion */
ix = mp_bpoly2arr(&pp, ptemp, 10);
if (
(ix != 5) ||
(ptemp[0] != p[0]) ||
(ptemp[1] != p[1]) ||
(ptemp[2] != p[2]) ||
(ptemp[3] != p[3]) ||
(ptemp[4] != p[4])) {
printf("Polynomial to array conversion not correct\n");
return -1;
}
printf("Polynomial conversion test #1 successful.\n");
MP_CHECKOK(mp_barr2poly(p, &c));
if (mp_cmp(&pp, &c) != 0) {
printf("Array to polynomial conversion not correct\n");
return -1;
}
printf("Polynomial conversion test #2 successful.\n");
/* Test addition */
MP_CHECKOK(mp_badd(&a, &a, &c));
if (mp_cmp_z(&c) != 0) {
printf("a+a should equal zero\n");
return -1;
}
printf("Addition test #1 successful.\n");
MP_CHECKOK(mp_badd(&a, &b, &c));
MP_CHECKOK(mp_badd(&b, &c, &c));
if (mp_cmp(&c, &a) != 0) {
printf("c = (a + b) + b should equal a\n");
printf("a = ");
mp_print(&a, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Addition test #2 successful.\n");
/* Test multiplication */
mp_set(&c, 2);
MP_CHECKOK(mp_bmul(&b, &c, &c));
MP_CHECKOK(mp_badd(&b, &c, &c));
mp_set(&d, 3);
MP_CHECKOK(mp_bmul(&b, &d, &d));
if (mp_cmp(&c, &d) != 0) {
printf("c = (2 * b) + b should equal c = 3 * b\n");
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("d = ");
mp_print(&d, stdout);
fputc('\n', stdout);
return -1;
}
printf("Multiplication test #1 successful.\n");
/* Test modular reduction */
MP_CHECKOK(mp_bmod(&b, p, &c));
if (mp_cmp(&b, &c) != 0) {
printf("c = b mod p should equal b\n");
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular reduction test #1 successful.\n");
MP_CHECKOK(mp_badd(&b, &pp, &c));
MP_CHECKOK(mp_bmod(&c, p, &c));
if (mp_cmp(&b, &c) != 0) {
printf("c = (b + p) mod p should equal b\n");
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular reduction test #2 successful.\n");
MP_CHECKOK(mp_bmul(&b, &pp, &c));
MP_CHECKOK(mp_bmod(&c, p, &c));
if (mp_cmp_z(&c) != 0) {
printf("c = (b * p) mod p should equal 0\n");
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular reduction test #3 successful.\n");
/* Test modular multiplication */
MP_CHECKOK(mp_bmulmod(&b, &pp, p, &c));
if (mp_cmp_z(&c) != 0) {
printf("c = (b * p) mod p should equal 0\n");
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular multiplication test #1 successful.\n");
mp_set(&c, 1);
MP_CHECKOK(mp_badd(&pp, &c, &c));
MP_CHECKOK(mp_bmulmod(&b, &c, p, &c));
if (mp_cmp(&b, &c) != 0) {
printf("c = (b * (p + 1)) mod p should equal b\n");
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular multiplication test #2 successful.\n");
/* Test modular squaring */
MP_CHECKOK(mp_copy(&b, &c));
MP_CHECKOK(mp_bmulmod(&b, &c, p, &c));
MP_CHECKOK(mp_bsqrmod(&b, p, &d));
if (mp_cmp(&c, &d) != 0) {
printf("c = (b * b) mod p should equal d = b^2 mod p\n");
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
printf("d = ");
mp_print(&d, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular squaring test #1 successful.\n");
/* Test modular division */
MP_CHECKOK(mp_bdivmod(&b, &x, &pp, p, &c));
MP_CHECKOK(mp_bmulmod(&c, &x, p, &c));
if (mp_cmp(&b, &c) != 0) {
printf("c = (b / x) * x mod p should equal b\n");
printf("b = ");
mp_print(&b, stdout);
fputc('\n', stdout);
printf("c = ");
mp_print(&c, stdout);
fputc('\n', stdout);
return -1;
}
printf("Modular division test #1 successful.\n");
CLEANUP:
mp_clear(&order);
mp_clear(&y);
mp_clear(&x);
mp_clear(&b);
mp_clear(&a);
mp_clear(&pp);
return 0;
}

1
security/nss/lib/freebl/mpi/tests/pi1k.txt
View file

@ -1 +0,0 @@
31415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989

1
security/nss/lib/freebl/mpi/tests/pi2k.txt
View file

@ -1 +0,0 @@
314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019893809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913151557485724245415069595082953311686172785588907509838175463746493931925506040092770167113900984882401285836160356370766010471018194295559619894676783744944825537977472684710404753464620804668425906949129331367702898915210475216205696602405803815019351125338243003558764024749647326391419927260426992279678235478163600934172164121992458631503028618297455570674983850549458858692699569092721079750930295532116534498720275596023648066549911988183479775356636980742654252786255181841757467289097777279380008164706001614524919217321721477235014144197356854816136115735255213347574184946843852332390739414333454776241686251898356948556209921922218427255025425688767179049460165346680498862723279178608578438382796797668145410095388378636095068006422512520511739298489608412848862694560424196528502221066118630674427862203919494504712371378696095636437191728746776465757396241389086583264599581339047802759010

1
security/nss/lib/freebl/mpi/tests/pi5k.txt
View file

File diff suppressed because one or more lines are too long

99
security/nss/lib/freebl/mpi/timetest
View file

@ -1,99 +0,0 @@
#!/bin/sh
# Simple timing test for the MPI library. Basically, we use prime
# generation as a timing test, since it exercises most of the pathways
# of the library fairly heavily. The 'primegen' tool outputs a line
# summarizing timing results. We gather these and process them for
# statistical information, which is collected into a file.
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
# Avoid using built-in shell echoes
ECHO=/bin/echo
MAKE=gmake
PERL=perl
# Use a fixed seed so timings will be more consistent
# This one is the 11th-18th decimal digits of 'e'
#export SEED=45904523
SEED=45904523; export SEED
#------------------------------------------------------------------------
$ECHO "\n** Running timing tests for MPI library\n"
$ECHO "Bringing 'metime' up to date ... "
if $MAKE metime ; then
:
else
$ECHO "\nMake failed to build metime.\n"
exit 1
fi
if [ ! -x ./metime ] ; then
$ECHO "\nCannot find 'metime' program, testing cannot continue.\n"
exit 1
fi
#------------------------------------------------------------------------
$ECHO "Bringing 'primegen' up to date ... "
if $MAKE primegen ; then
:
else
$ECHO "\nMake failed to build primegen.\n"
exit 1
fi
if [ ! -x ./primegen ] ; then
$ECHO "\nCannot find 'primegen' program, testing cannot continue.\n"
exit 1
fi
#------------------------------------------------------------------------
rm -f timing-results.txt
touch timing-results.txt
sizes="256 512 1024 2048"
ntests=10
trap 'echo "oop!";rm -f tt*.tmp timing-results.txt;exit 0' INT HUP
$ECHO "\n-- Modular exponentiation\n"
$ECHO "Modular exponentiation:" >> timing-results.txt
$ECHO "Running $ntests modular exponentiations per test:"
for size in $sizes ; do
$ECHO "- Gathering statistics for $size bits ... "
secs=`./metime $ntests $size | tail -1 | awk '{print $2}'`
$ECHO "$size: " $secs " seconds per op" >> timing-results.txt
tail -1 timing-results.txt
done
$ECHO "<done>";
sizes="256 512 1024"
ntests=1
$ECHO "\n-- Prime generation\n"
$ECHO "Prime generation:" >> timing-results.txt
$ECHO "Generating $ntests prime values per test:"
for size in $sizes ; do
$ECHO "- Gathering statistics for $size bits ... "
./primegen $size $ntests | grep ticks | awk '{print $7}' | tr -d '(' > tt$$.tmp
$ECHO "$size:" >> timing-results.txt
$PERL stats tt$$.tmp >> timing-results.txt
tail -1 timing-results.txt
rm -f tt$$.tmp
done
$ECHO "<done>"
trap 'rm -f tt*.tmp timing-results.txt' INT HUP
exit 0

127
security/nss/lib/freebl/mpi/types.pl
View file

@ -1,127 +0,0 @@
#!/usr/bin/perl
#
# types.pl - find recommended type definitions for digits and words
#
# This script scans the Makefile for the C compiler and compilation
# flags currently in use, and using this combination, attempts to
# compile a simple test program that outputs the sizes of the various
# unsigned integer types, in bytes. Armed with these, it finds all
# the "viable" type combinations for mp_digit and mp_word, where
# viability is defined by the requirement that mp_word be at least two
# times the precision of mp_digit.
#
# Of these, the one with the largest digit size is chosen, and
# appropriate typedef statements are written to standard output.
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
@_=split(/\//,$0);chomp($prog=pop(@_));
# The array of integer types to be considered...
@TYPES = (
"unsigned char",
"unsigned short",
"unsigned int",
"unsigned long"
);
# Macro names for the maximum unsigned value of each type
%TMAX = (
"unsigned char" => "UCHAR_MAX",
"unsigned short" => "USHRT_MAX",
"unsigned int" => "UINT_MAX",
"unsigned long" => "ULONG_MAX"
);
# Read the Makefile to find out which C compiler to use
open(MFP, "<Makefile") or die "$prog: Makefile: $!\n";
while(<MFP>) {
chomp;
if(/^CC=(.*)$/) {
$cc = $1;
last if $cflags;
} elsif(/^CFLAGS=(.*)$/) {
$cflags = $1;
last if $cc;
}
}
close(MFP);
# If we couldn't find that, use 'cc' by default
$cc = "cc" unless $cc;
printf STDERR "Using '%s' as the C compiler.\n", $cc;
print STDERR "Determining type sizes ... \n";
open(OFP, ">tc$$.c") or die "$prog: tc$$.c: $!\n";
print OFP "#include <stdio.h>\n\nint main(void)\n{\n";
foreach $type (@TYPES) {
printf OFP "\tprintf(\"%%d\\n\", (int)sizeof(%s));\n", $type;
}
print OFP "\n\treturn 0;\n}\n";
close(OFP);
system("$cc $cflags -o tc$$ tc$$.c");
die "$prog: unable to build test program\n" unless(-x "tc$$");
open(IFP, "./tc$$|") or die "$prog: can't execute test program\n";
$ix = 0;
while(<IFP>) {
chomp;
$size{$TYPES[$ix++]} = $_;
}
close(IFP);
unlink("tc$$");
unlink("tc$$.c");
print STDERR "Selecting viable combinations ... \n";
while(($type, $size) = each(%size)) {
push(@ts, [ $size, $type ]);
}
# Sort them ascending by size
@ts = sort { $a->[0] <=> $b->[0] } @ts;
# Try all possible combinations, finding pairs in which the word size
# is twice the digit size. The number of possible pairs is too small
# to bother doing this more efficiently than by brute force
for($ix = 0; $ix <= $#ts; $ix++) {
$w = $ts[$ix];
for($jx = 0; $jx <= $#ts; $jx++) {
$d = $ts[$jx];
if($w->[0] == 2 * $d->[0]) {
push(@valid, [ $d, $w ]);
}
}
}
# Sort descending by digit size
@valid = sort { $b->[0]->[0] <=> $a->[0]->[0] } @valid;
# Select the maximum as the recommended combination
$rec = shift(@valid);
printf("typedef %-18s mp_sign;\n", "char");
printf("typedef %-18s mp_digit; /* %d byte type */\n",
$rec->[0]->[1], $rec->[0]->[0]);
printf("typedef %-18s mp_word; /* %d byte type */\n",
$rec->[1]->[1], $rec->[1]->[0]);
printf("typedef %-18s mp_size;\n", "unsigned int");
printf("typedef %-18s mp_err;\n\n", "int");
printf("#define %-18s (CHAR_BIT*sizeof(mp_digit))\n", "DIGIT_BIT");
printf("#define %-18s %s\n", "DIGIT_MAX", $TMAX{$rec->[0]->[1]});
printf("#define %-18s (CHAR_BIT*sizeof(mp_word))\n", "MP_WORD_BIT");
printf("#define %-18s %s\n\n", "MP_WORD_MAX", $TMAX{$rec->[1]->[1]});
printf("#define %-18s (DIGIT_MAX+1)\n\n", "RADIX");
printf("#define %-18s \"%%0%dX\"\n", "DIGIT_FMT", (2 * $rec->[0]->[0]));
exit 0;

4
security/nss/lib/freebl/mpi/utils/LICENSE
View file

@ -1,4 +0,0 @@
Within this directory, each of the file listed below is licensed under
the terms given in the file LICENSE-MPL, also in this directory.
PRIMES

3
security/nss/lib/freebl/mpi/utils/LICENSE-MPL
View file

@ -1,3 +0,0 @@
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.

41
security/nss/lib/freebl/mpi/utils/PRIMES
View file

@ -1,41 +0,0 @@
Probable primes (sorted by number of significant bits)
128: 81386202757205669562183851789305348631
128: 180241813863264101444573802809858694397
128: 245274683055224433281596312431122059021
128: 187522309397665259809392608791686659539
256: 83252422946206411852330647237287722547866360773229941071371588246436\
513990159
256: 79132571131322331023736933767063051273085304521895229780914612117520\
058517909
256: 72081815425552909748220041100909735706208853818662000557743644603407\
965465527
256: 87504602391905701494845474079163412737334477797316409702279059573654\
274811271
512: 12233064210800062190450937494718705259777386009095453001870729392786\
63450255179083524798507997690270500580265258111668148238355016411719\
9168737693316468563
512: 12003639081420725322369909586347545220275253633035565716386136197501\
88208318984400479275215620499883521216480724155582768193682335576385\
2069481074929084063
1024: 16467877625718912296741904171202513097057724053648819680815842057593\
20371835940722471475475803725455063836431454757000451907612224427007\
63984592414360595161051906727075047683803534852982766542661204179549\
77327573530800542562611753617736693359790119074768292178493884576587\
0230450429880021317876149636714743053
1024: 16602953991090311275234291158294516471009930684624948451178742895360\
86073703307475884280944414508444679430090561246728195735962931545473\
40743240318558456247740186704660778277799687988031119436541068736925\
20563780233711166724859277827382391527748470939542560819625727876091\
5372193745283891895989104479029844957

206
security/nss/lib/freebl/mpi/utils/README
View file

@ -1,206 +0,0 @@
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
Additional MPI utilities
------------------------
The files 'mpprime.h' and 'mpprime.c' define some useful extensions to
the MPI library for dealing with prime numbers (in particular, testing
for divisbility, and the Rabin-Miller probabilistic primality test).
The files 'mplogic.h' and 'mplogic.c' define extensions to the MPI
library for doing bitwise logical operations and shifting.
This document assumes you have read the help file for the MPI library
and understand its conventions.
Divisibility (mpprime.h)
------------
To test a number for divisibility by another number:
mpp_divis(a, b) - test if b|a
mpp_divis_d(a, d) - test if d|a
Each of these functions returns MP_YES if its initial argument is
divisible by its second, or MP_NO if it is not. Other errors may be
returned as appropriate (such as MP_RANGE if you try to test for
divisibility by zero).
Randomness (mpprime.h)
----------
To generate random data:
mpp_random(a) - fill a with random data
mpp_random_size(a, p) - fill a with p digits of random data
The mpp_random_size() function increases the precision of a to at
least p, then fills all those digits randomly. The mp_random()
function fills a to its current precision (as determined by the number
of significant digits, USED(a))
Note that these functions simply use the C library's rand() function
to fill a with random digits up to its precision. This should be
adequate for primality testing, but should not be used for
cryptographic applications where truly random values are required for
security.
You should call srand() in your driver program in order to seed the
random generator; this function doesn't call it.
Primality Testing (mpprime.h)
-----------------
mpp_divis_vector(a, v, s, w) - is a divisible by any of the s values
in v, and if so, w = which.
mpp_divis_primes(a, np) - is a divisible by any of the first np primes?
mpp_fermat(a, w) - is a pseudoprime with respect to witness w?
mpp_pprime(a, nt) - run nt iterations of Rabin-Miller on a.
The mpp_divis_vector() function tests a for divisibility by each
member of an array of digits. The array is v, the size of that array
is s. Returns MP_YES if a is divisible, and stores the index of the
offending digit in w. Returns MP_NO if a is not divisible by any of
the digits in the array.
A small table of primes is compiled into the library (typically the
first 128 primes, although you can change this by editing the file
'primes.c' before you build). The global variable prime_tab_size
contains the number of primes in the table, and the values themselves
are in the array prime_tab[], which is an array of mp_digit.
The mpp_divis_primes() function is basically just a wrapper around
mpp_divis_vector() that uses prime_tab[] as the test vector. The np
parameter is a pointer to an mp_digit -- on input, it should specify
the number of primes to be tested against. If a is divisible by any
of the primes, MP_YES is returned and np is given the prime value that
divided a (you can use this if you're factoring, for example).
Otherwise, MP_NO is returned and np is untouched.
The function mpp_fermat() performs Fermat's test, using w as a
witness. This test basically relies on the fact that if a is prime,
and w is relatively prime to a, then:
w^a = w (mod a)
That is,
w^(a - 1) = 1 (mod a)
The function returns MP_YES if the test passes, MP_NO if it fails. If
w is relatively prime to a, and the test fails, a is definitely
composite. If w is relatively prime to a and the test passes, then a
is either prime, or w is a false witness (the probability of this
happening depends on the choice of w and of a ... consult a number
theory textbook for more information about this).
Note: If (w, a) != 1, the output of this test is meaningless.
----
The function mpp_pprime() performs the Rabin-Miller probabilistic
primality test for nt rounds. If all the tests pass, MP_YES is
returned, and a is probably prime. The probability that an answer of
MP_YES is incorrect is no greater than 1 in 4^nt, and in fact is
usually much less than that (this is a pessimistic estimate). If any
test fails, MP_NO is returned, and a is definitely composite.
Bruce Schneier recommends at least 5 iterations of this test for most
cryptographic applications; Knuth suggests that 25 are reasonable.
Run it as many times as you feel are necessary.
See the programs 'makeprime.c' and 'isprime.c' for reasonable examples
of how to use these functions for primality testing.
Bitwise Logic (mplogic.c)
-------------
The four commonest logical operations are implemented as:
mpl_not(a, b) - Compute bitwise (one's) complement, b = ~a
mpl_and(a, b, c) - Compute bitwise AND, c = a & b
mpl_or(a, b, c) - Compute bitwise OR, c = a | b
mpl_xor(a, b, c) - Compute bitwise XOR, c = a ^ b
Left and right shifts are available as well. These take a number to
shift, a destination, and a shift amount. The shift amount must be a
digit value between 0 and DIGIT_BIT inclusive; if it is not, MP_RANGE
will be returned and the shift will not happen.
mpl_rsh(a, b, d) - Compute logical right shift, b = a >> d
mpl_lsh(a, b, d) - Compute logical left shift, b = a << d
Since these are logical shifts, they fill with zeroes (the library
uses a signed magnitude representation, so there are no sign bits to
extend anyway).
Command-line Utilities
----------------------
A handful of interesting command-line utilities are provided. These
are:
lap.c - Find the order of a mod m. Usage is 'lap <a> <m>'.
This uses a dumb algorithm, so don't use it for
a really big modulus.
invmod.c - Find the inverse of a mod m, if it exists. Usage
is 'invmod <a> <m>'
sieve.c - A simple bitmap-based implementation of the Sieve
of Eratosthenes. Used to generate the table of
primes in primes.c. Usage is 'sieve <nbits>'
prng.c - Uses the routines in bbs_rand.{h,c} to generate
one or more 32-bit pseudo-random integers. This
is mainly an example, not intended for use in a
cryptographic application (the system time is
the only source of entropy used)
dec2hex.c - Convert decimal to hexadecimal
hex2dec.c - Convert hexadecimal to decimal
basecvt.c - General radix conversion tool (supports 2-64)
isprime.c - Probabilistically test an integer for primality
using the Rabin-Miller pseudoprime test combined
with division by small primes.
primegen.c - Generate primes at random.
exptmod.c - Perform modular exponentiation
ptab.pl - A Perl script to munge the output of the sieve
program into a compilable C structure.
Other Files
-----------
PRIMES - Some randomly generated numbers which are prime with
extremely high probability.
README - You're reading me already.
About the Author
----------------
This software was written by Michael J. Fromberger. You can contact
the author as follows:
E-mail: <sting@linguist.dartmouth.edu>
Postal: 8000 Cummings Hall, Thayer School of Engineering
Dartmouth College, Hanover, New Hampshire, USA
PGP key: http://linguist.dartmouth.edu/~sting/keys/mjf.html
9736 188B 5AFA 23D6 D6AA BE0D 5856 4525 289D 9907

68
security/nss/lib/freebl/mpi/utils/basecvt.c
View file

@ -1,68 +0,0 @@
/*
* basecvt.c
*
* Convert integer values specified on the command line from one input
* base to another. Accepts input and output bases between 2 and 36
* inclusive.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
#define IBASE 10
#define OBASE 16
#define USAGE "Usage: %s ibase obase [value]\n"
#define MAXBASE 64
#define MINBASE 2
int
main(int argc, char *argv[])
{
int ix, ibase = IBASE, obase = OBASE;
mp_int val;
ix = 1;
if (ix < argc) {
ibase = atoi(argv[ix++]);
if (ibase < MINBASE || ibase > MAXBASE) {
fprintf(stderr, "%s: input radix must be between %d and %d inclusive\n",
argv[0], MINBASE, MAXBASE);
return 1;
}
}
if (ix < argc) {
obase = atoi(argv[ix++]);
if (obase < MINBASE || obase > MAXBASE) {
fprintf(stderr, "%s: output radix must be between %d and %d inclusive\n",
argv[0], MINBASE, MAXBASE);
return 1;
}
}
mp_init(&val);
while (ix < argc) {
char *out;
int outlen;
mp_read_radix(&val, argv[ix++], ibase);
outlen = mp_radix_size(&val, obase);
out = calloc(outlen, sizeof(char));
mp_toradix(&val, out, obase);
printf("%s\n", out);
free(out);
}
mp_clear(&val);
return 0;
}

65
security/nss/lib/freebl/mpi/utils/bbs_rand.c
View file

@ -1,65 +0,0 @@
/*
* Blum, Blum & Shub PRNG using the MPI library
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "bbs_rand.h"
#define SEED 1
#define MODULUS 2
/* This modulus is the product of two randomly generated 512-bit
prime integers, each of which is congruent to 3 (mod 4). */
static char *bbs_modulus =
"75A2A6E1D27393B86562B9CE7279A8403CB4258A637DAB5233465373E37837383EDC"
"332282B8575927BC4172CE8C147B4894050EE9D2BDEED355C121037270CA2570D127"
"7D2390CD1002263326635CC6B259148DE3A1A03201980A925E395E646A5E9164B0EC"
"28559EBA58C87447245ADD0651EDA507056A1129E3A3E16E903D64B437";
static int bbs_init = 0; /* flag set when library is initialized */
static mp_int bbs_state; /* the current state of the generator */
/* Suggested size of random seed data */
int bbs_seed_size = (sizeof(bbs_modulus) / 2);
void
bbs_srand(unsigned char *data, int len)
{
if ((bbs_init & SEED) == 0) {
mp_init(&bbs_state);
bbs_init |= SEED;
}
mp_read_raw(&bbs_state, (char *)data, len);
} /* end bbs_srand() */
unsigned int
bbs_rand(void)
{
static mp_int modulus;
unsigned int result = 0, ix;
if ((bbs_init & MODULUS) == 0) {
mp_init(&modulus);
mp_read_radix(&modulus, bbs_modulus, 16);
bbs_init |= MODULUS;
}
for (ix = 0; ix < sizeof(unsigned int); ix++) {
mp_digit d;
mp_sqrmod(&bbs_state, &modulus, &bbs_state);
d = DIGIT(&bbs_state, 0);
result = (result << CHAR_BIT) | (d & UCHAR_MAX);
}
return result;
} /* end bbs_rand() */
/*------------------------------------------------------------------------*/
/* HERE THERE BE DRAGONS */

24
security/nss/lib/freebl/mpi/utils/bbs_rand.h
View file

@ -1,24 +0,0 @@
/*
* bbs_rand.h
*
* Blum, Blum & Shub PRNG using the MPI library
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef _H_BBSRAND_
#define _H_BBSRAND_
#include <limits.h>
#include "mpi.h"
#define BBS_RAND_MAX UINT_MAX
/* Suggested length of seed data */
extern int bbs_seed_size;
void bbs_srand(unsigned char *data, int len);
unsigned int bbs_rand(void);
#endif /* end _H_BBSRAND_ */

35
security/nss/lib/freebl/mpi/utils/bbsrand.c
View file

@ -1,35 +0,0 @@
/*
* bbsrand.c
*
* Test driver for routines in bbs_rand.h
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <limits.h>
#include "bbs_rand.h"
#define NUM_TESTS 100
int
main(void)
{
unsigned int seed, result, ix;
seed = time(NULL);
bbs_srand((unsigned char *)&seed, sizeof(seed));
for (ix = 0; ix < NUM_TESTS; ix++) {
result = bbs_rand();
printf("Test %3u: %08X\n", ix + 1, result);
}
return 0;
}

40
security/nss/lib/freebl/mpi/utils/dec2hex.c
View file

@ -1,40 +0,0 @@
/*
* dec2hex.c
*
* Convert decimal integers into hexadecimal
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
mp_int a;
char *buf;
int len;
if (argc < 2) {
fprintf(stderr, "Usage: %s <a>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_read_radix(&a, argv[1], 10);
len = mp_radix_size(&a, 16);
buf = malloc(len);
mp_toradix(&a, buf, 16);
printf("%s\n", buf);
free(buf);
mp_clear(&a);
return 0;
}

55
security/nss/lib/freebl/mpi/utils/exptmod.c
View file

@ -1,55 +0,0 @@
/*
* exptmod.c
*
* Command line tool to perform modular exponentiation on arbitrary
* precision integers.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
mp_int a, b, m;
mp_err res;
char *str;
int len, rval = 0;
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b> <m>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_init(&b);
mp_init(&m);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&b, argv[2], 10);
mp_read_radix(&m, argv[3], 10);
if ((res = mp_exptmod(&a, &b, &m, &a)) != MP_OKAY) {
fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res));
rval = 1;
} else {
len = mp_radix_size(&a, 10);
str = calloc(len, sizeof(char));
mp_toradix(&a, str, 10);
printf("%s\n", str);
free(str);
}
mp_clear(&a);
mp_clear(&b);
mp_clear(&m);
return rval;
}

84
security/nss/lib/freebl/mpi/utils/fact.c
View file

@ -1,84 +0,0 @@
/*
* fact.c
*
* Compute factorial of input integer
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
mp_err mp_fact(mp_int *a, mp_int *b);
int
main(int argc, char *argv[])
{
mp_int a;
mp_err res;
if (argc < 2) {
fprintf(stderr, "Usage: %s <number>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_read_radix(&a, argv[1], 10);
if ((res = mp_fact(&a, &a)) != MP_OKAY) {
fprintf(stderr, "%s: error: %s\n", argv[0],
mp_strerror(res));
mp_clear(&a);
return 1;
}
{
char *buf;
int len;
len = mp_radix_size(&a, 10);
buf = malloc(len);
mp_todecimal(&a, buf);
puts(buf);
free(buf);
}
mp_clear(&a);
return 0;
}
mp_err
mp_fact(mp_int *a, mp_int *b)
{
mp_int ix, s;
mp_err res = MP_OKAY;
if (mp_cmp_z(a) < 0)
return MP_UNDEF;
mp_init(&s);
mp_add_d(&s, 1, &s); /* s = 1 */
mp_init(&ix);
mp_add_d(&ix, 1, &ix); /* ix = 1 */
for (/* */; mp_cmp(&ix, a) <= 0; mp_add_d(&ix, 1, &ix)) {
if ((res = mp_mul(&s, &ix, &s)) != MP_OKAY)
break;
}
mp_clear(&ix);
/* Copy out results if we got them */
if (res == MP_OKAY)
mp_copy(&s, b);
mp_clear(&s);
return res;
}

95
security/nss/lib/freebl/mpi/utils/gcd.c
View file

@ -1,95 +0,0 @@
/*
* gcd.c
*
* Greatest common divisor
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
char *g_prog = NULL;
void print_mp_int(mp_int *mp, FILE *ofp);
int
main(int argc, char *argv[])
{
mp_int a, b, x, y;
mp_err res;
int ext = 0;
g_prog = argv[0];
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <b>\n", g_prog);
return 1;
}
mp_init(&a);
mp_read_radix(&a, argv[1], 10);
mp_init(&b);
mp_read_radix(&b, argv[2], 10);
/* If we were called 'xgcd', compute x, y so that g = ax + by */
if (strcmp(g_prog, "xgcd") == 0) {
ext = 1;
mp_init(&x);
mp_init(&y);
}
if (ext) {
if ((res = mp_xgcd(&a, &b, &a, &x, &y)) != MP_OKAY) {
fprintf(stderr, "%s: error: %s\n", g_prog, mp_strerror(res));
mp_clear(&a);
mp_clear(&b);
mp_clear(&x);
mp_clear(&y);
return 1;
}
} else {
if ((res = mp_gcd(&a, &b, &a)) != MP_OKAY) {
fprintf(stderr, "%s: error: %s\n", g_prog,
mp_strerror(res));
mp_clear(&a);
mp_clear(&b);
return 1;
}
}
print_mp_int(&a, stdout);
if (ext) {
fputs("x = ", stdout);
print_mp_int(&x, stdout);
fputs("y = ", stdout);
print_mp_int(&y, stdout);
}
mp_clear(&a);
mp_clear(&b);
if (ext) {
mp_clear(&x);
mp_clear(&y);
}
return 0;
}
void
print_mp_int(mp_int *mp, FILE *ofp)
{
char *buf;
int len;
len = mp_radix_size(mp, 10);
buf = calloc(len, sizeof(char));
mp_todecimal(mp, buf);
fprintf(ofp, "%s\n", buf);
free(buf);
}

40
security/nss/lib/freebl/mpi/utils/hex2dec.c
View file

@ -1,40 +0,0 @@
/*
* hex2dec.c
*
* Convert decimal integers into hexadecimal
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
mp_int a;
char *buf;
int len;
if (argc < 2) {
fprintf(stderr, "Usage: %s <a>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_read_radix(&a, argv[1], 16);
len = mp_radix_size(&a, 10);
buf = malloc(len);
mp_toradix(&a, buf, 10);
printf("%s\n", buf);
free(buf);
mp_clear(&a);
return 0;
}

84
security/nss/lib/freebl/mpi/utils/identest.c
View file

@ -1,84 +0,0 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include "mpi.h"
#include "mpprime.h"
#include <sys/types.h>
#include <time.h>
#define MAX_PREC (4096 / MP_DIGIT_BIT)
mp_err
identity_test(void)
{
mp_size preca, precb;
mp_err res;
mp_int a, b;
mp_int t1, t2, t3, t4, t5;
preca = (rand() % MAX_PREC) + 1;
precb = (rand() % MAX_PREC) + 1;
MP_DIGITS(&a) = 0;
MP_DIGITS(&b) = 0;
MP_DIGITS(&t1) = 0;
MP_DIGITS(&t2) = 0;
MP_DIGITS(&t3) = 0;
MP_DIGITS(&t4) = 0;
MP_DIGITS(&t5) = 0;
MP_CHECKOK(mp_init(&a));
MP_CHECKOK(mp_init(&b));
MP_CHECKOK(mp_init(&t1));
MP_CHECKOK(mp_init(&t2));
MP_CHECKOK(mp_init(&t3));
MP_CHECKOK(mp_init(&t4));
MP_CHECKOK(mp_init(&t5));
MP_CHECKOK(mpp_random_size(&a, preca));
MP_CHECKOK(mpp_random_size(&b, precb));
if (mp_cmp(&a, &b) < 0)
mp_exch(&a, &b);
MP_CHECKOK(mp_mod(&a, &b, &t1)); /* t1 = a%b */
MP_CHECKOK(mp_div(&a, &b, &t2, NULL)); /* t2 = a/b */
MP_CHECKOK(mp_mul(&b, &t2, &t3)); /* t3 = (a/b)*b */
MP_CHECKOK(mp_add(&t1, &t3, &t4)); /* t4 = a%b + (a/b)*b */
MP_CHECKOK(mp_sub(&t4, &a, &t5)); /* t5 = a%b + (a/b)*b - a */
if (mp_cmp_z(&t5) != 0) {
res = MP_UNDEF;
goto CLEANUP;
}
CLEANUP:
mp_clear(&t5);
mp_clear(&t4);
mp_clear(&t3);
mp_clear(&t2);
mp_clear(&t1);
mp_clear(&b);
mp_clear(&a);
return res;
}
int
main(void)
{
unsigned int seed = (unsigned int)time(NULL);
unsigned long count = 0;
mp_err res;
srand(seed);
while (MP_OKAY == (res = identity_test())) {
if ((++count % 100) == 0)
fputc('.', stderr);
}
fprintf(stderr, "\ntest failed, err %d\n", res);
return res;
}

61
security/nss/lib/freebl/mpi/utils/invmod.c
View file

@ -1,61 +0,0 @@
/*
* invmod.c
*
* Compute modular inverses
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include "mpi.h"
int
main(int argc, char *argv[])
{
mp_int a, m;
mp_err res;
char *buf;
int len, out = 0;
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <m>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_init(&m);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&m, argv[2], 10);
if (mp_cmp(&a, &m) > 0)
mp_mod(&a, &m, &a);
switch ((res = mp_invmod(&a, &m, &a))) {
case MP_OKAY:
len = mp_radix_size(&a, 10);
buf = malloc(len);
mp_toradix(&a, buf, 10);
printf("%s\n", buf);
free(buf);
break;
case MP_UNDEF:
printf("No inverse\n");
out = 1;
break;
default:
printf("error: %s (%d)\n", mp_strerror(res), res);
out = 2;
break;
}
mp_clear(&a);
mp_clear(&m);
return out;
}

89
security/nss/lib/freebl/mpi/utils/isprime.c
View file

@ -1,89 +0,0 @@
/*
* isprime.c
*
* Probabilistic primality tester command-line tool
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mpi.h"
#include "mpprime.h"
#define RM_TESTS 15 /* how many iterations of Rabin-Miller? */
#define MINIMUM 1024 /* don't bother us with a < this */
int g_tests = RM_TESTS;
char *g_prog = NULL;
int
main(int argc, char *argv[])
{
mp_int a;
mp_digit np = prime_tab_size; /* from mpprime.h */
int res = 0;
g_prog = argv[0];
if (argc < 2) {
fprintf(stderr, "Usage: %s <a>, where <a> is a decimal integer\n"
"Use '0x' prefix for a hexadecimal value\n",
g_prog);
return 1;
}
/* Read number of tests from environment, if present */
{
char *tmp;
if ((tmp = PR_GetEnvSecure("RM_TESTS")) != NULL) {
if ((g_tests = atoi(tmp)) <= 0)
g_tests = RM_TESTS;
}
}
mp_init(&a);
if (argv[1][0] == '0' && argv[1][1] == 'x')
mp_read_radix(&a, argv[1] + 2, 16);
else
mp_read_radix(&a, argv[1], 10);
if (mp_cmp_d(&a, MINIMUM) <= 0) {
fprintf(stderr, "%s: please use a value greater than %d\n",
g_prog, MINIMUM);
mp_clear(&a);
return 1;
}
/* Test for divisibility by small primes */
if (mpp_divis_primes(&a, &np) != MP_NO) {
printf("Not prime (divisible by small prime %d)\n", np);
res = 2;
goto CLEANUP;
}
/* Test with Fermat's test, using 2 as a witness */
if (mpp_fermat(&a, 2) != MP_YES) {
printf("Not prime (failed Fermat test)\n");
res = 2;
goto CLEANUP;
}
/* Test with Rabin-Miller probabilistic test */
if (mpp_pprime(&a, g_tests) == MP_NO) {
printf("Not prime (failed pseudoprime test)\n");
res = 2;
goto CLEANUP;
}
printf("Probably prime, 1 in 4^%d chance of false positive\n", g_tests);
CLEANUP:
mp_clear(&a);
return res;
}

90
security/nss/lib/freebl/mpi/utils/lap.c
View file

@ -1,90 +0,0 @@
/*
* lap.c
*
* Find least annihilating power of a mod m
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include "mpi.h"
void sig_catch(int ign);
int g_quit = 0;
int
main(int argc, char *argv[])
{
mp_int a, m, p, k;
if (argc < 3) {
fprintf(stderr, "Usage: %s <a> <m>\n", argv[0]);
return 1;
}
mp_init(&a);
mp_init(&m);
mp_init(&p);
mp_add_d(&p, 1, &p);
mp_read_radix(&a, argv[1], 10);
mp_read_radix(&m, argv[2], 10);
mp_init_copy(&k, &a);
signal(SIGINT, sig_catch);
#ifndef __OS2__
signal(SIGHUP, sig_catch);
#endif
signal(SIGTERM, sig_catch);
while (mp_cmp(&p, &m) < 0) {
if (g_quit) {
int len;
char *buf;
len = mp_radix_size(&p, 10);
buf = malloc(len);
mp_toradix(&p, buf, 10);
fprintf(stderr, "Terminated at: %s\n", buf);
free(buf);
return 1;
}
if (mp_cmp_d(&k, 1) == 0) {
int len;
char *buf;
len = mp_radix_size(&p, 10);
buf = malloc(len);
mp_toradix(&p, buf, 10);
printf("%s\n", buf);
free(buf);
break;
}
mp_mulmod(&k, &a, &m, &k);
mp_add_d(&p, 1, &p);
}
if (mp_cmp(&p, &m) >= 0)
printf("No annihilating power.\n");
mp_clear(&p);
mp_clear(&m);
mp_clear(&a);
return 0;
}
void
sig_catch(int ign)
{
g_quit = 1;
}

116
security/nss/lib/freebl/mpi/utils/makeprime.c
View file

@ -1,116 +0,0 @@
/*
* makeprime.c
*
* A simple prime generator function (and test driver). Prints out the
* first prime it finds greater than or equal to the starting value.
*
* Usage: makeprime <start>
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
/* These two must be included for make_prime() to work */
#include "mpi.h"
#include "mpprime.h"
/*
make_prime(p, nr)
Find the smallest prime integer greater than or equal to p, where
primality is verified by 'nr' iterations of the Rabin-Miller
probabilistic primality test. The caller is responsible for
generating the initial value of p.
Returns MP_OKAY if a prime has been generated, otherwise the error
code indicates some other problem. The value of p is clobbered; the
caller should keep a copy if the value is needed.
*/
mp_err make_prime(mp_int *p, int nr);
/* The main() is not required -- it's just a test driver */
int
main(int argc, char *argv[])
{
mp_int start;
mp_err res;
if (argc < 2) {
fprintf(stderr, "Usage: %s <start-value>\n", argv[0]);
return 1;
}
mp_init(&start);
if (argv[1][0] == '0' && tolower(argv[1][1]) == 'x') {
mp_read_radix(&start, argv[1] + 2, 16);
} else {
mp_read_radix(&start, argv[1], 10);
}
mp_abs(&start, &start);
if ((res = make_prime(&start, 5)) != MP_OKAY) {
fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res));
mp_clear(&start);
return 1;
} else {
char *buf = malloc(mp_radix_size(&start, 10));
mp_todecimal(&start, buf);
printf("%s\n", buf);
free(buf);
mp_clear(&start);
return 0;
}
} /* end main() */
/*------------------------------------------------------------------------*/
mp_err
make_prime(mp_int *p, int nr)
{
mp_err res;
if (mp_iseven(p)) {
mp_add_d(p, 1, p);
}
do {
mp_digit which = prime_tab_size;
/* First test for divisibility by a few small primes */
if ((res = mpp_divis_primes(p, &which)) == MP_YES)
continue;
else if (res != MP_NO)
goto CLEANUP;
/* If that passes, try one iteration of Fermat's test */
if ((res = mpp_fermat(p, 2)) == MP_NO)
continue;
else if (res != MP_YES)
goto CLEANUP;
/* If that passes, run Rabin-Miller as often as requested */
if ((res = mpp_pprime(p, nr)) == MP_YES)
break;
else if (res != MP_NO)
goto CLEANUP;
} while ((res = mp_add_d(p, 2, p)) == MP_OKAY);
CLEANUP:
return res;
} /* end make_prime() */
/*------------------------------------------------------------------------*/
/* HERE THERE BE DRAGONS */

102
security/nss/lib/freebl/mpi/utils/metime.c
View file

@ -1,102 +0,0 @@
/*
* metime.c
*
* Modular exponentiation timing test
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <time.h>
#include "mpi.h"
#include "mpprime.h"
double clk_to_sec(clock_t start, clock_t stop);
int
main(int argc, char *argv[])
{
int ix, num, prec = 8;
unsigned int seed;
clock_t start, stop;
double sec;
mp_int a, m, c;
if (PR_GetEnvSecure("SEED") != NULL)
seed = abs(atoi(PR_GetEnvSecure("SEED")));
else
seed = (unsigned int)time(NULL);
if (argc < 2) {
fprintf(stderr, "Usage: %s <num-tests> [<nbits>]\n", argv[0]);
return 1;
}
if ((num = atoi(argv[1])) < 0)
num = -num;
if (!num) {
fprintf(stderr, "%s: must perform at least 1 test\n", argv[0]);
return 1;
}
if (argc > 2) {
if ((prec = atoi(argv[2])) <= 0)
prec = 8;
else
prec = (prec + (DIGIT_BIT - 1)) / DIGIT_BIT;
}
printf("Modular exponentiation timing test\n"
"Precision: %d digits (%d bits)\n"
"# of tests: %d\n\n",
prec, prec * DIGIT_BIT, num);
mp_init_size(&a, prec);
mp_init_size(&m, prec);
mp_init_size(&c, prec);
srand(seed);
start = clock();
for (ix = 0; ix < num; ix++) {
mpp_random_size(&a, prec);
mpp_random_size(&c, prec);
mpp_random_size(&m, prec);
/* set msb and lsb of m */
DIGIT(&m, 0) |= 1;
DIGIT(&m, USED(&m) - 1) |= (mp_digit)1 << (DIGIT_BIT - 1);
if (mp_cmp(&a, &m) > 0)
mp_sub(&a, &m, &a);
mp_exptmod(&a, &c, &m, &c);
}
stop = clock();
sec = clk_to_sec(start, stop);
printf("Total: %.3f seconds\n", sec);
printf("Individual: %.3f seconds\n", sec / num);
mp_clear(&c);
mp_clear(&a);
mp_clear(&m);
return 0;
}
double
clk_to_sec(clock_t start, clock_t stop)
{
return (double)(stop - start) / CLOCKS_PER_SEC;
}
/*------------------------------------------------------------------------*/
/* HERE THERE BE DRAGONS */

171
security/nss/lib/freebl/mpi/utils/pi.c
View file

@ -1,171 +0,0 @@
/*
* pi.c
*
* Compute pi to an arbitrary number of digits. Uses Machin's formula,
* like everyone else on the planet:
*
* pi = 16 * arctan(1/5) - 4 * arctan(1/239)
*
* This is pretty effective for up to a few thousand digits, but it
* gets pretty slow after that.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <time.h>
#include "mpi.h"
mp_err arctan(mp_digit mul, mp_digit x, mp_digit prec, mp_int *sum);
int
main(int argc, char *argv[])
{
mp_err res;
mp_digit ndigits;
mp_int sum1, sum2;
clock_t start, stop;
int out = 0;
/* Make the user specify precision on the command line */
if (argc < 2) {
fprintf(stderr, "Usage: %s <num-digits>\n", argv[0]);
return 1;
}
if ((ndigits = abs(atoi(argv[1]))) == 0) {
fprintf(stderr, "%s: you must request at least 1 digit\n", argv[0]);
return 1;
}
start = clock();
mp_init(&sum1);
mp_init(&sum2);
/* sum1 = 16 * arctan(1/5) */
if ((res = arctan(16, 5, ndigits, &sum1)) != MP_OKAY) {
fprintf(stderr, "%s: arctan: %s\n", argv[0], mp_strerror(res));
out = 1;
goto CLEANUP;
}
/* sum2 = 4 * arctan(1/239) */
if ((res = arctan(4, 239, ndigits, &sum2)) != MP_OKAY) {
fprintf(stderr, "%s: arctan: %s\n", argv[0], mp_strerror(res));
out = 1;
goto CLEANUP;
}
/* pi = sum1 - sum2 */
if ((res = mp_sub(&sum1, &sum2, &sum1)) != MP_OKAY) {
fprintf(stderr, "%s: mp_sub: %s\n", argv[0], mp_strerror(res));
out = 1;
goto CLEANUP;
}
stop = clock();
/* Write the output in decimal */
{
char *buf = malloc(mp_radix_size(&sum1, 10));
if (buf == NULL) {
fprintf(stderr, "%s: out of memory\n", argv[0]);
out = 1;
goto CLEANUP;
}
mp_todecimal(&sum1, buf);
printf("%s\n", buf);
free(buf);
}
fprintf(stderr, "Computation took %.2f sec.\n",
(double)(stop - start) / CLOCKS_PER_SEC);
CLEANUP:
mp_clear(&sum1);
mp_clear(&sum2);
return out;
}
/* Compute sum := mul * arctan(1/x), to 'prec' digits of precision */
mp_err
arctan(mp_digit mul, mp_digit x, mp_digit prec, mp_int *sum)
{
mp_int t, v;
mp_digit q = 1, rd;
mp_err res;
int sign = 1;
prec += 3; /* push inaccuracies off the end */
mp_init(&t);
mp_set(&t, 10);
mp_init(&v);
if ((res = mp_expt_d(&t, prec, &t)) != MP_OKAY || /* get 10^prec */
(res = mp_mul_d(&t, mul, &t)) != MP_OKAY || /* ... times mul */
(res = mp_mul_d(&t, x, &t)) != MP_OKAY) /* ... times x */
goto CLEANUP;
/*
The extra multiplication by x in the above takes care of what
would otherwise have to be a special case for 1 / x^1 during the
first loop iteration. A little sneaky, but effective.
We compute arctan(1/x) by the formula:
1 1 1 1
- - ----- + ----- - ----- + ...
x 3 x^3 5 x^5 7 x^7
We multiply through by 'mul' beforehand, which gives us a couple
more iterations and more precision
*/
x *= x; /* works as long as x < sqrt(RADIX), which it is here */
mp_zero(sum);
do {
if ((res = mp_div_d(&t, x, &t, &rd)) != MP_OKAY)
goto CLEANUP;
if (sign < 0 && rd != 0)
mp_add_d(&t, 1, &t);
if ((res = mp_div_d(&t, q, &v, &rd)) != MP_OKAY)
goto CLEANUP;
if (sign < 0 && rd != 0)
mp_add_d(&v, 1, &v);
if (sign > 0)
res = mp_add(sum, &v, sum);
else
res = mp_sub(sum, &v, sum);
if (res != MP_OKAY)
goto CLEANUP;
sign *= -1;
q += 2;
} while (mp_cmp_z(&t) != 0);
/* Chop off inaccurate low-order digits */
mp_div_d(sum, 1000, sum, NULL);
CLEANUP:
mp_clear(&v);
mp_clear(&t);
return res;
}
/*------------------------------------------------------------------------*/
/* HERE THERE BE DRAGONS */

159
security/nss/lib/freebl/mpi/utils/primegen.c
View file

@ -1,159 +0,0 @@
/*
* primegen.c
*
* Generates random integers which are prime with a high degree of
* probability using the Miller-Rabin probabilistic primality testing
* algorithm.
*
* Usage:
* primegen <bits> [<num>]
*
* <bits> - number of significant bits each prime should have
* <num> - number of primes to generate
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <time.h>
#include "mpi.h"
#include "mplogic.h"
#include "mpprime.h"
#define NUM_TESTS 5 /* Number of Rabin-Miller iterations to test with */
#ifdef DEBUG
#define FPUTC(x, y) fputc(x, y)
#else
#define FPUTC(x, y)
#endif
int
main(int argc, char *argv[])
{
unsigned char *raw;
char *out;
unsigned long nTries;
int rawlen, bits, outlen, ngen, ix, jx;
int g_strong = 0;
mp_int testval;
mp_err res;
clock_t start, end;
/* We'll just use the C library's rand() for now, although this
won't be good enough for cryptographic purposes */
if ((out = PR_GetEnvSecure("SEED")) == NULL) {
srand((unsigned int)time(NULL));
} else {
srand((unsigned int)atoi(out));
}
if (argc < 2) {
fprintf(stderr, "Usage: %s <bits> [<count> [strong]]\n", argv[0]);
return 1;
}
if ((bits = abs(atoi(argv[1]))) < CHAR_BIT) {
fprintf(stderr, "%s: please request at least %d bits.\n",
argv[0], CHAR_BIT);
return 1;
}
/* If optional third argument is given, use that as the number of
primes to generate; otherwise generate one prime only.
*/
if (argc < 3) {
ngen = 1;
} else {
ngen = abs(atoi(argv[2]));
}
/* If fourth argument is given, and is the word "strong", we'll
generate strong (Sophie Germain) primes.
*/
if (argc > 3 && strcmp(argv[3], "strong") == 0)
g_strong = 1;
/* testval - candidate being tested; nTries - number tried so far */
if ((res = mp_init(&testval)) != MP_OKAY) {
fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res));
return 1;
}
if (g_strong) {
printf("Requested %d strong prime value(s) of %d bits.\n",
ngen, bits);
} else {
printf("Requested %d prime value(s) of %d bits.\n", ngen, bits);
}
rawlen = (bits / CHAR_BIT) + ((bits % CHAR_BIT) ? 1 : 0) + 1;
if ((raw = calloc(rawlen, sizeof(unsigned char))) == NULL) {
fprintf(stderr, "%s: out of memory, sorry.\n", argv[0]);
return 1;
}
/* This loop is one for each prime we need to generate */
for (jx = 0; jx < ngen; jx++) {
raw[0] = 0; /* sign is positive */
/* Pack the initializer with random bytes */
for (ix = 1; ix < rawlen; ix++)
raw[ix] = (rand() * rand()) & UCHAR_MAX;
raw[1] |= 0x80; /* set high-order bit of test value */
raw[rawlen - 1] |= 1; /* set low-order bit of test value */
/* Make an mp_int out of the initializer */
mp_read_raw(&testval, (char *)raw, rawlen);
/* Initialize candidate counter */
nTries = 0;
start = clock(); /* time generation for this prime */
do {
res = mpp_make_prime(&testval, bits, g_strong, &nTries);
if (res != MP_NO)
break;
/* This code works whether digits are 16 or 32 bits */
res = mp_add_d(&testval, 32 * 1024, &testval);
res = mp_add_d(&testval, 32 * 1024, &testval);
FPUTC(',', stderr);
} while (1);
end = clock();
if (res != MP_YES) {
break;
}
FPUTC('\n', stderr);
puts("The following value is probably prime:");
outlen = mp_radix_size(&testval, 10);
out = calloc(outlen, sizeof(unsigned char));
mp_toradix(&testval, (char *)out, 10);
printf("10: %s\n", out);
mp_toradix(&testval, (char *)out, 16);
printf("16: %s\n\n", out);
free(out);
printf("Number of candidates tried: %lu\n", nTries);
printf("This computation took %ld clock ticks (%.2f seconds)\n",
(end - start), ((double)(end - start) / CLOCKS_PER_SEC));
FPUTC('\n', stderr);
} /* end of loop to generate all requested primes */
if (res != MP_OKAY)
fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res));
free(raw);
mp_clear(&testval);
return 0;
}

57
security/nss/lib/freebl/mpi/utils/prng.c
View file

@ -1,57 +0,0 @@
/*
* prng.c
*
* Command-line pseudo-random number generator
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <time.h>
#ifdef __OS2__
#include <types.h>
#include <process.h>
#else
#include <unistd.h>
#endif
#include "bbs_rand.h"
int
main(int argc, char *argv[])
{
unsigned char *seed;
unsigned int ix, num = 1;
pid_t pid;
if (argc > 1) {
num = atoi(argv[1]);
if (num <= 0)
num = 1;
}
pid = getpid();
srand(time(NULL) * (unsigned int)pid);
/* Not a perfect seed, but not bad */
seed = malloc(bbs_seed_size);
for (ix = 0; ix < bbs_seed_size; ix++) {
seed[ix] = rand() % UCHAR_MAX;
}
bbs_srand(seed, bbs_seed_size);
memset(seed, 0, bbs_seed_size);
free(seed);
while (num-- > 0) {
ix = bbs_rand();
printf("%u\n", ix);
}
return 0;
}

26
security/nss/lib/freebl/mpi/utils/ptab.pl
View file

@ -1,26 +0,0 @@
#!/usr/bin/perl
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
while(<>) {
chomp;
push(@primes, $_);
}
printf("mp_size prime_tab_size = %d;\n", ($#primes + 1));
print "mp_digit prime_tab[] = {\n";
print "\t";
$last = pop(@primes);
foreach $prime (sort {$a<=>$b} @primes) {
printf("0x%04X, ", $prime);
$brk = ($brk + 1) % 8;
print "\n\t" if(!$brk);
}
printf("0x%04X", $last);
print "\n" if($brk);
print "};\n\n";
exit 0;

243
security/nss/lib/freebl/mpi/utils/sieve.c
View file

@ -1,243 +0,0 @@
/*
* sieve.c
*
* Finds prime numbers using the Sieve of Eratosthenes
*
* This implementation uses a bitmap to represent all odd integers in a
* given range. We iterate over this bitmap, crossing off the
* multiples of each prime we find. At the end, all the remaining set
* bits correspond to prime integers.
*
* Here, we make two passes -- once we have generated a sieve-ful of
* primes, we copy them out, reset the sieve using the highest
* generated prime from the first pass as a base. Then we cross out
* all the multiples of all the primes we found the first time through,
* and re-sieve. In this way, we get double use of the memory we
* allocated for the sieve the first time though. Since we also
* implicitly ignore multiples of 2, this amounts to 4 times the
* values.
*
* This could (and probably will) be generalized to re-use the sieve a
* few more times.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
typedef unsigned char byte;
typedef struct {
int size;
byte *bits;
long base;
int next;
int nbits;
} sieve;
void sieve_init(sieve *sp, long base, int nbits);
void sieve_grow(sieve *sp, int nbits);
long sieve_next(sieve *sp);
void sieve_reset(sieve *sp, long base);
void sieve_cross(sieve *sp, long val);
void sieve_clear(sieve *sp);
#define S_ISSET(S, B) (((S)->bits[(B) / CHAR_BIT] >> ((B) % CHAR_BIT)) & 1)
#define S_SET(S, B) ((S)->bits[(B) / CHAR_BIT] |= (1 << ((B) % CHAR_BIT)))
#define S_CLR(S, B) ((S)->bits[(B) / CHAR_BIT] &= ~(1 << ((B) % CHAR_BIT)))
#define S_VAL(S, B) ((S)->base + (2 * (B)))
#define S_BIT(S, V) (((V) - ((S)->base)) / 2)
int
main(int argc, char *argv[])
{
sieve s;
long pr, *p;
int c, ix, cur = 0;
if (argc < 2) {
fprintf(stderr, "Usage: %s <width>\n", argv[0]);
return 1;
}
c = atoi(argv[1]);
if (c < 0)
c = -c;
fprintf(stderr, "%s: sieving to %d positions\n", argv[0], c);
sieve_init(&s, 3, c);
c = 0;
while ((pr = sieve_next(&s)) > 0) {
++c;
}
p = calloc(c, sizeof(long));
if (!p) {
fprintf(stderr, "%s: out of memory after first half\n", argv[0]);
sieve_clear(&s);
exit(1);
}
fprintf(stderr, "%s: half done ... \n", argv[0]);
for (ix = 0; ix < s.nbits; ix++) {
if (S_ISSET(&s, ix)) {
p[cur] = S_VAL(&s, ix);
printf("%ld\n", p[cur]);
++cur;
}
}
sieve_reset(&s, p[cur - 1]);
fprintf(stderr, "%s: crossing off %d found primes ... \n", argv[0], cur);
for (ix = 0; ix < cur; ix++) {
sieve_cross(&s, p[ix]);
if (!(ix % 1000))
fputc('.', stderr);
}
fputc('\n', stderr);
free(p);
fprintf(stderr, "%s: sieving again from %ld ... \n", argv[0], p[cur - 1]);
c = 0;
while ((pr = sieve_next(&s)) > 0) {
++c;
}
fprintf(stderr, "%s: done!\n", argv[0]);
for (ix = 0; ix < s.nbits; ix++) {
if (S_ISSET(&s, ix)) {
printf("%ld\n", S_VAL(&s, ix));
}
}
sieve_clear(&s);
return 0;
}
void
sieve_init(sieve *sp, long base, int nbits)
{
sp->size = (nbits / CHAR_BIT);
if (nbits % CHAR_BIT)
++sp->size;
sp->bits = calloc(sp->size, sizeof(byte));
memset(sp->bits, UCHAR_MAX, sp->size);
if (!(base & 1))
++base;
sp->base = base;
sp->next = 0;
sp->nbits = sp->size * CHAR_BIT;
}
void
sieve_grow(sieve *sp, int nbits)
{
int ns = (nbits / CHAR_BIT);
if (nbits % CHAR_BIT)
++ns;
if (ns > sp->size) {
byte *tmp;
int ix;
tmp = calloc(ns, sizeof(byte));
if (tmp == NULL) {
fprintf(stderr, "Error: out of memory in sieve_grow\n");
return;
}
memcpy(tmp, sp->bits, sp->size);
for (ix = sp->size; ix < ns; ix++) {
tmp[ix] = UCHAR_MAX;
}
free(sp->bits);
sp->bits = tmp;
sp->size = ns;
sp->nbits = sp->size * CHAR_BIT;
}
}
long
sieve_next(sieve *sp)
{
long out;
int ix = 0;
long val;
if (sp->next > sp->nbits)
return -1;
out = S_VAL(sp, sp->next);
#ifdef DEBUG
fprintf(stderr, "Sieving %ld\n", out);
#endif
/* Sieve out all multiples of the current prime */
val = out;
while (ix < sp->nbits) {
val += out;
ix = S_BIT(sp, val);
if ((val & 1) && ix < sp->nbits) { /* && S_ISSET(sp, ix)) { */
S_CLR(sp, ix);
#ifdef DEBUG
fprintf(stderr, "Crossing out %ld (bit %d)\n", val, ix);
#endif
}
}
/* Scan ahead to the next prime */
++sp->next;
while (sp->next < sp->nbits && !S_ISSET(sp, sp->next))
++sp->next;
return out;
}
void
sieve_cross(sieve *sp, long val)
{
int ix = 0;
long cur = val;
while (cur < sp->base)
cur += val;
ix = S_BIT(sp, cur);
while (ix < sp->nbits) {
if (cur & 1)
S_CLR(sp, ix);
cur += val;
ix = S_BIT(sp, cur);
}
}
void
sieve_reset(sieve *sp, long base)
{
memset(sp->bits, UCHAR_MAX, sp->size);
sp->base = base;
sp->next = 0;
}
void
sieve_clear(sieve *sp)
{
if (sp->bits)
free(sp->bits);
sp->bits = NULL;
}