pax_global_header 0000666 0000000 0000000 00000000064 14745512304 0014517 g ustar 00root root 0000000 0000000 52 comment=354f0015a5524f45a94df0656c2ec358256c2d52
tinyssh-20250126/ 0000775 0000000 0000000 00000000000 14745512304 0013463 5 ustar 00root root 0000000 0000000 tinyssh-20250126/.clang-format 0000664 0000000 0000000 00000011032 14745512304 0016033 0 ustar 00root root 0000000 0000000 # 20211227
# based on LLVM
# AllowShortBlocksOnASingleLine: Always
# AllowShortLoopsOnASingleLine: true
# AllowShortIfStatementsOnASingleLine: WithoutElse
# IndentWidth: 4
# TabWidth: 4
# SortIncludes: false
# BreakBeforeBraces: Custom
# BeforeElse: true
# ColumnLimit: 80
# SpaceAfterCStyleCast: true
# IndentCaseLabels: true
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: false
AlignConsecutiveAssignments: false
AlignConsecutiveBitFields: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: true
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
- Regex: '.*'
Priority: 1
SortPriority: 0
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: true
IndentCaseBlocks: false
IndentGotoLabels: true
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentWidth: 4
IndentWrappedFunctionNames: false
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments: true
SortIncludes: false
SortUsingDeclarations: true
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
# XXX - should be false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: Latest
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 4
UseCRLF: false
UseTab: Never
WhitespaceSensitiveMacros:
- STRINGIZE
- PP_STRINGIZE
- BOOST_PP_STRINGIZE
...
tinyssh-20250126/.gitignore 0000664 0000000 0000000 00000000007 14745512304 0015450 0 ustar 00root root 0000000 0000000 /build
tinyssh-20250126/CHANGELOG.md 0000664 0000000 0000000 00000004102 14745512304 0015271 0 ustar 00root root 0000000 0000000 ### 20250126 (pre-relase)
- Fixed more compiler warnings
- More used cryptoint
### 20241201 (pre-relase)
- Switched to [cryptoint](https://libntruprime.cr.yp.to/libntruprime-20241021/cryptoint.html) 20241003
- Switched to tests from [SUPERCOP](https://bench.cr.yp.to/supercop.html) for crypto primitives
- Fixed various compiler warnings
### 20241111 (pre-relase)
- Fixed implicit-function-declaration warning packet_put.c (tnx @lanodan)
- Modification of the build system to a simple Makefile (old build system still in directory 'old')
- Added support for external librandombytes, lib25519, libntruprime library
- Dropped support for other NaCl-compatible external libraries
- Temporary disabled unit tests.
### 20240101
- fixed channel_forkpty() race condition between close(slave) in parent process and login_tty(slave) in child process
- fixed behavior when using terminal mode and stdin redirected to /dev/null 'ssh -tt -n'
- added an 'strict-key' key exchange kex-strict-s-v00@openssh.com (Mitigates CVE-2023-48795 "Terrapin attack")
### 20230101
- LICENCE update from public-domain to CC0, public domain works differently depending on the country, to avoid it, set explicitly CC0
- fixed sysdep tests, tnx Johannes Nixdorf
### 20220801
- tinyssh/getln.c don't close fd in case of error
- use null fields in utmpx calls for logout
- do not reverse the argument order in LIBS
- fill utmp(x)'s ut_addr_v6 field when it exists
- updated crypto/crypto_onetimeauth_poly1305.c
### 20220311
- fixed build on big-endian platforms
### 20220305 (workaround release)
- use PACKET_LIMIT/2 as incoming maximum packet size, it's workaround for packets with miscalculated packet_length
### 20220222
- add tinysshnoneauthd
### 20220101
- add tinysshnoneauthd
- fixed return error message when second channel is requested
- man/tinysshd-{make,print}key.1 -> man/tinysshd-{make,print}key.8
### 20210601
- add tools/tinyssh-convert
- fix log error messages
- honor "max packet size" requested from the client
### 20210319
- removed sntrup4591761x25519-sha512@tinyssh.org
- added sntrup761x25519-sha512@openssh.com
tinyssh-20250126/LICENCE 0000664 0000000 0000000 00000015610 14745512304 0014453 0 ustar 00root root 0000000 0000000 Creative Commons Legal Code
CC0 1.0 Universal
CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
HEREUNDER.
Statement of Purpose
The laws of most jurisdictions throughout the world automatically confer
exclusive Copyright and Related Rights (defined below) upon the creator
and subsequent owner(s) (each and all, an "owner") of an original work of
authorship and/or a database (each, a "Work").
Certain owners wish to permanently relinquish those rights to a Work for
the purpose of contributing to a commons of creative, cultural and
scientific works ("Commons") that the public can reliably and without fear
of later claims of infringement build upon, modify, incorporate in other
works, reuse and redistribute as freely as possible in any form whatsoever
and for any purposes, including without limitation commercial purposes.
These owners may contribute to the Commons to promote the ideal of a free
culture and the further production of creative, cultural and scientific
works, or to gain reputation or greater distribution for their Work in
part through the use and efforts of others.
For these and/or other purposes and motivations, and without any
expectation of additional consideration or compensation, the person
associating CC0 with a Work (the "Affirmer"), to the extent that he or she
is an owner of Copyright and Related Rights in the Work, voluntarily
elects to apply CC0 to the Work and publicly distribute the Work under its
terms, with knowledge of his or her Copyright and Related Rights in the
Work and the meaning and intended legal effect of CC0 on those rights.
1. Copyright and Related Rights. A Work made available under CC0 may be
protected by copyright and related or neighboring rights ("Copyright and
Related Rights"). Copyright and Related Rights include, but are not
limited to, the following:
i. the right to reproduce, adapt, distribute, perform, display,
communicate, and translate a Work;
ii. moral rights retained by the original author(s) and/or performer(s);
iii. publicity and privacy rights pertaining to a person's image or
likeness depicted in a Work;
iv. rights protecting against unfair competition in regards to a Work,
subject to the limitations in paragraph 4(a), below;
v. rights protecting the extraction, dissemination, use and reuse of data
in a Work;
vi. database rights (such as those arising under Directive 96/9/EC of the
European Parliament and of the Council of 11 March 1996 on the legal
protection of databases, and under any national implementation
thereof, including any amended or successor version of such
directive); and
vii. other similar, equivalent or corresponding rights throughout the
world based on applicable law or treaty, and any national
implementations thereof.
2. Waiver. To the greatest extent permitted by, but not in contravention
of, applicable law, Affirmer hereby overtly, fully, permanently,
irrevocably and unconditionally waives, abandons, and surrenders all of
Affirmer's Copyright and Related Rights and associated claims and causes
of action, whether now known or unknown (including existing as well as
future claims and causes of action), in the Work (i) in all territories
worldwide, (ii) for the maximum duration provided by applicable law or
treaty (including future time extensions), (iii) in any current or future
medium and for any number of copies, and (iv) for any purpose whatsoever,
including without limitation commercial, advertising or promotional
purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
member of the public at large and to the detriment of Affirmer's heirs and
successors, fully intending that such Waiver shall not be subject to
revocation, rescission, cancellation, termination, or any other legal or
equitable action to disrupt the quiet enjoyment of the Work by the public
as contemplated by Affirmer's express Statement of Purpose.
3. Public License Fallback. Should any part of the Waiver for any reason
be judged legally invalid or ineffective under applicable law, then the
Waiver shall be preserved to the maximum extent permitted taking into
account Affirmer's express Statement of Purpose. In addition, to the
extent the Waiver is so judged Affirmer hereby grants to each affected
person a royalty-free, non transferable, non sublicensable, non exclusive,
irrevocable and unconditional license to exercise Affirmer's Copyright and
Related Rights in the Work (i) in all territories worldwide, (ii) for the
maximum duration provided by applicable law or treaty (including future
time extensions), (iii) in any current or future medium and for any number
of copies, and (iv) for any purpose whatsoever, including without
limitation commercial, advertising or promotional purposes (the
"License"). The License shall be deemed effective as of the date CC0 was
applied by Affirmer to the Work. Should any part of the License for any
reason be judged legally invalid or ineffective under applicable law, such
partial invalidity or ineffectiveness shall not invalidate the remainder
of the License, and in such case Affirmer hereby affirms that he or she
will not (i) exercise any of his or her remaining Copyright and Related
Rights in the Work or (ii) assert any associated claims and causes of
action with respect to the Work, in either case contrary to Affirmer's
express Statement of Purpose.
4. Limitations and Disclaimers.
a. No trademark or patent rights held by Affirmer are waived, abandoned,
surrendered, licensed or otherwise affected by this document.
b. Affirmer offers the Work as-is and makes no representations or
warranties of any kind concerning the Work, express, implied,
statutory or otherwise, including without limitation warranties of
title, merchantability, fitness for a particular purpose, non
infringement, or the absence of latent or other defects, accuracy, or
the present or absence of errors, whether or not discoverable, all to
the greatest extent permissible under applicable law.
c. Affirmer disclaims responsibility for clearing rights of other persons
that may apply to the Work or any use thereof, including without
limitation any person's Copyright and Related Rights in the Work.
Further, Affirmer disclaims responsibility for obtaining any necessary
consents, permissions or other rights required for any use of the
Work.
d. Affirmer understands and acknowledges that Creative Commons is not a
party to this document and has no duty or obligation with respect to
this CC0 or use of the Work.
tinyssh-20250126/Makefile 0000664 0000000 0000000 00000144200 14745512304 0015124 0 ustar 00root root 0000000 0000000 CC?=cc
CFLAGS+=-W -Wall -Os -fPIC -fwrapv -Werror=deprecated-declarations -Icryptoint
LDFLAGS?=
CPPFLAGS?=
DESTDIR?=
PREFIX?=/usr/local
INSTALL?=install
LINKS=tinysshd-makekey tinysshd-printkey tinysshnoneauthd
BINARIES=tinysshd _tinysshd-printkex _tinysshd-speed _tinysshd-test-hello1 \
_tinysshd-test-hello2 _tinysshd-test-kex1 _tinysshd-test-kex2 \
_tinysshd-unauthenticated
TESTCRYPTOBINARIES=test-crypto
OBJLIB=blocking.o buf.o byte.o channel.o channel_drop.o channel_fork.o \
channel_forkpty.o channel_subsystem.o cleanup.o coe.o connectioninfo.o \
crypto_dh_x25519.o crypto_hash_sha256.o crypto_hash_sha512_lib25519.o \
crypto_hash_sha512_tinyssh.o crypto_kem_sntrup761_libntruprime.o \
crypto_kem_sntrup761_tinyssh.o crypto_kem_sntrup761x25519.o \
crypto_onetimeauth_poly1305.o crypto_scalarmult_curve25519.o \
crypto_sign_ed25519_lib25519.o crypto_sign_ed25519_tinyssh.o \
crypto_sort_uint32.o crypto_stream_chacha20.o crypto_verify_16.o \
crypto_verify_32.o die.o dropuidgid.o e.o env.o fe25519.o fe.o ge25519.o \
getln.o global.o int16_optblocker.o int32_optblocker.o int64_optblocker.o \
int8_optblocker.o iptostr.o load.o log.o loginshell.o logsys.o main_tinysshd.o \
main_tinysshd_makekey.o main_tinysshd_printkey.o newenv.o numtostr.o open.o \
packet_auth.o packet.o packet_channel_open.o packet_channel_recv.o \
packet_channel_request.o packet_channel_send.o packet_get.o packet_hello.o \
packet_kex.o packet_kexdh.o packetparser.o packet_put.o packet_recv.o \
packet_send.o packet_unimplemented.o porttostr.o randommod.o readall.o \
savesync.o sc25519.o ssh.o sshcrypto.o sshcrypto_cipher.o \
sshcrypto_cipher_chachapoly.o sshcrypto_kex.o sshcrypto_kex_curve25519.o \
sshcrypto_kex_sntrup761x25519.o sshcrypto_key.o sshcrypto_key_ed25519.o str.o \
stringparser.o subprocess_auth.o subprocess_sign.o trymlock.o \
uint16_optblocker.o uint32_optblocker.o uint64_optblocker.o uint8_optblocker.o \
writeall.o
OBJALL=blocking.o buf.o byte.o channel.o channel_drop.o channel_fork.o \
channel_forkpty.o channel_subsystem.o cleanup.o coe.o connectioninfo.o \
crypto_dh_x25519.o crypto_hash_sha256.o crypto_hash_sha512_lib25519.o \
crypto_hash_sha512_tinyssh.o crypto_kem_sntrup761_libntruprime.o \
crypto_kem_sntrup761_tinyssh.o crypto_kem_sntrup761x25519.o \
crypto_onetimeauth_poly1305.o crypto_scalarmult_curve25519.o \
crypto_sign_ed25519_lib25519.o crypto_sign_ed25519_tinyssh.o \
crypto_sort_uint32.o crypto_stream_chacha20.o crypto_verify_16.o \
crypto_verify_32.o die.o dropuidgid.o e.o env.o fe25519.o fe.o ge25519.o \
getln.o global.o int16_optblocker.o int32_optblocker.o int64_optblocker.o \
int8_optblocker.o iptostr.o load.o log.o loginshell.o logsys.o main_tinysshd.o \
main_tinysshd_makekey.o main_tinysshd_printkey.o newenv.o numtostr.o open.o \
packet_auth.o packet.o packet_channel_open.o packet_channel_recv.o \
packet_channel_request.o packet_channel_send.o packet_get.o packet_hello.o \
packet_kex.o packet_kexdh.o packetparser.o packet_put.o packet_recv.o \
packet_send.o packet_unimplemented.o porttostr.o randombytes.o randommod.o \
readall.o savesync.o sc25519.o ssh.o sshcrypto.o sshcrypto_cipher.o \
sshcrypto_cipher_chachapoly.o sshcrypto_kex.o sshcrypto_kex_curve25519.o \
sshcrypto_kex_sntrup761x25519.o sshcrypto_key.o sshcrypto_key_ed25519.o str.o \
stringparser.o subprocess_auth.o subprocess_sign.o test-crypto.o tinysshd.o \
_tinysshd-printkex.o _tinysshd-speed.o _tinysshd-test-hello1.o \
_tinysshd-test-hello2.o _tinysshd-test-kex1.o _tinysshd-test-kex2.o \
_tinysshd-unauthenticated.o trymlock.o uint16_optblocker.o uint32_optblocker.o \
uint64_optblocker.o uint8_optblocker.o writeall.o
AUTOHEADERS=haslib25519.h haslibntruprime.h haslibrandombytes.h haslibutilh.h \
haslimits.h haslogintty.h hasmlock.h hasopenpty.h hasutilh.h hasutmpaddrv6.h \
hasutmp.h hasutmphost.h hasutmploginlogout.h hasutmplogwtmp.h hasutmpname.h \
hasutmppid.h hasutmptime.h hasutmptv.h hasutmptype.h hasutmpuser.h \
hasutmpxaddrv6.h hasutmpx.h hasutmpxsyslen.h hasutmpxupdwtmpx.h hasvalgrind.h
TESTOUT=test-crypto-dh.out test-crypto-hash.out test-crypto-kem.out \
test-crypto-sign.out test-crypto-sort.out test-crypto-verify.out \
test-tinysshd-makekey.out test-tinysshd-printkey.out test-tinysshd.out \
test-tinysshnoneauthd.out
all: $(AUTOHEADERS) $(BINARIES) $(LINKS)
blocking.o: blocking.c blocking.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c blocking.c
buf.o: buf.c byte.h str.h purge.h cleanup.h randombytes.h \
haslibrandombytes.h cryptoint/crypto_uint32.h bug.h global.h e.h log.h \
buf.h cryptoint/crypto_uint8.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c buf.c
byte.o: byte.c cryptoint/crypto_int16.h byte.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c byte.c
channel.o: channel.c byte.h bug.h global.h e.h log.h newenv.h purge.h \
cleanup.h connectioninfo.h iptostr.h porttostr.h buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h str.h logsys.h \
loginshell.h trymlock.h limit.h haslimits.h channel.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c channel.c
channel_drop.o: channel_drop.c dropuidgid.h newenv.h channel.h \
cryptoint/crypto_uint32.h iptostr.h porttostr.h limit.h haslimits.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c channel_drop.c
channel_fork.o: channel_fork.c blocking.h open.h channel.h \
cryptoint/crypto_uint32.h iptostr.h porttostr.h limit.h haslimits.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c channel_fork.c
channel_forkpty.o: channel_forkpty.c hasopenpty.h haslogintty.h e.h coe.h \
blocking.h global.h channel.h cryptoint/crypto_uint32.h iptostr.h \
porttostr.h limit.h haslimits.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c channel_forkpty.c
channel_subsystem.o: channel_subsystem.c str.h log.h e.h channel.h \
cryptoint/crypto_uint32.h iptostr.h porttostr.h limit.h haslimits.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c channel_subsystem.c
cleanup.o: cleanup.c cleanup.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c cleanup.c
coe.o: coe.c coe.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c coe.c
connectioninfo.o: connectioninfo.c e.h byte.h iptostr.h porttostr.h env.h \
str.h connectioninfo.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c connectioninfo.c
crypto_dh_x25519.o: crypto_dh_x25519.c crypto_dh_x25519.h haslib25519.h \
randombytes.h haslibrandombytes.h crypto_scalarmult_curve25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_dh_x25519.c
crypto_hash_sha256.o: crypto_hash_sha256.c cryptoint/crypto_uint32.h \
cryptoint/crypto_uint64.h crypto_hash_sha256.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_hash_sha256.c
crypto_hash_sha512_lib25519.o: crypto_hash_sha512_lib25519.c \
haslib25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_hash_sha512_lib25519.c
crypto_hash_sha512_tinyssh.o: crypto_hash_sha512_tinyssh.c \
crypto_hash_sha512.h haslib25519.h cryptoint/crypto_uint64.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_hash_sha512_tinyssh.c
crypto_kem_sntrup761_libntruprime.o: crypto_kem_sntrup761_libntruprime.c \
haslibntruprime.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_kem_sntrup761_libntruprime.c
crypto_kem_sntrup761_tinyssh.o: crypto_kem_sntrup761_tinyssh.c \
crypto_kem_sntrup761.h haslibntruprime.h cryptoint/crypto_uint64.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int16.h \
cryptoint/crypto_int8.h randombytes.h haslibrandombytes.h \
crypto_verify_32.h crypto_sort_uint32.h crypto_hash_sha512.h \
haslib25519.h crypto_declassify.h hasvalgrind.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_kem_sntrup761_tinyssh.c
crypto_kem_sntrup761x25519.o: crypto_kem_sntrup761x25519.c cleanup.h \
crypto_hash_sha512.h haslib25519.h crypto_dh_x25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_kem_sntrup761x25519.c
crypto_onetimeauth_poly1305.o: crypto_onetimeauth_poly1305.c \
cryptoint/crypto_int16.h cryptoint/crypto_uint32.h \
cryptoint/crypto_uint64.h crypto_onetimeauth_poly1305.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_onetimeauth_poly1305.c
crypto_scalarmult_curve25519.o: crypto_scalarmult_curve25519.c cleanup.h \
fe25519.h fe.h cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h \
cryptoint/crypto_uint8.h crypto_scalarmult_curve25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_scalarmult_curve25519.c
crypto_sign_ed25519_lib25519.o: crypto_sign_ed25519_lib25519.c \
haslib25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_sign_ed25519_lib25519.c
crypto_sign_ed25519_tinyssh.o: crypto_sign_ed25519_tinyssh.c \
crypto_sign_ed25519.h haslib25519.h randombytes.h haslibrandombytes.h \
cleanup.h crypto_hash_sha512.h crypto_verify_32.h ge25519.h fe.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h sc25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_sign_ed25519_tinyssh.c
crypto_sort_uint32.o: crypto_sort_uint32.c cryptoint/crypto_uint32.h \
crypto_sort_uint32.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_sort_uint32.c
crypto_stream_chacha20.o: crypto_stream_chacha20.c \
crypto_stream_chacha20.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_stream_chacha20.c
crypto_verify_16.o: crypto_verify_16.c cryptoint/crypto_int16.h \
crypto_verify_16.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_verify_16.c
crypto_verify_32.o: crypto_verify_32.c cryptoint/crypto_int16.h \
crypto_verify_32.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c crypto_verify_32.c
die.o: die.c global.h log.h die.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c die.c
dropuidgid.o: dropuidgid.c e.h dropuidgid.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c dropuidgid.c
e.o: e.c e.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c e.c
env.o: env.c str.h env.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c env.c
fe25519.o: fe25519.c crypto_verify_32.h cleanup.h fe.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h fe25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c fe25519.c
fe.o: fe.c fe.h cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c fe.c
ge25519.o: ge25519.c fe25519.h fe.h cryptoint/crypto_uint32.h \
cryptoint/crypto_uint64.h cleanup.h ge25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c ge25519.c
getln.o: getln.c e.h getln.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c getln.c
global.o: global.c newenv.h channel.h cryptoint/crypto_uint32.h iptostr.h \
porttostr.h limit.h haslimits.h packet.h buf.h cryptoint/crypto_uint8.h \
sshcrypto.h crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h purge.h cleanup.h trymlock.h global.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c global.c
int16_optblocker.o: int16_optblocker.c cryptoint/crypto_int16.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c int16_optblocker.c
int32_optblocker.o: int32_optblocker.c cryptoint/crypto_int32.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c int32_optblocker.c
int64_optblocker.o: int64_optblocker.c cryptoint/crypto_int64.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c int64_optblocker.c
int8_optblocker.o: int8_optblocker.c cryptoint/crypto_int8.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c int8_optblocker.c
iptostr.o: iptostr.c byte.h iptostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c iptostr.c
load.o: load.c readall.h open.h e.h load.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c load.c
log.o: log.c writeall.h randommod.h purge.h cleanup.h numtostr.h e.h \
log.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c log.c
loginshell.o: loginshell.c e.h loginshell.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c loginshell.c
logsys.o: logsys.c hasutilh.h hasutmpx.h hasutmpxupdwtmpx.h \
hasutmpxsyslen.h hasutmpxaddrv6.h hasutmp.h hasutmpname.h hasutmppid.h \
hasutmptime.h hasutmptv.h hasutmptype.h hasutmphost.h hasutmpuser.h \
hasutmplogwtmp.h hasutmploginlogout.h hasutmpaddrv6.h str.h byte.h \
logsys.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c logsys.c
main_tinysshd.o: main_tinysshd.c blocking.h ssh.h purge.h cleanup.h \
open.h load.h e.h byte.h buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h packet.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h log.h subprocess.h global.h connectioninfo.h die.h str.h \
main.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c main_tinysshd.c
main_tinysshd_makekey.o: main_tinysshd_makekey.c savesync.h log.h \
sshcrypto.h buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h \
crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h global.h die.h main.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c main_tinysshd_makekey.c
main_tinysshd_printkey.o: main_tinysshd_printkey.c e.h load.h sshcrypto.h \
buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h global.h log.h writeall.h die.h main.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c main_tinysshd_printkey.c
newenv.o: newenv.c e.h byte.h str.h purge.h cleanup.h bug.h global.h \
log.h env.h trymlock.h newenv.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c newenv.c
numtostr.o: numtostr.c numtostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c numtostr.c
open.o: open.c blocking.h open.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c open.c
packet_auth.o: packet_auth.c buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h ssh.h e.h str.h packetparser.h subprocess.h \
sshcrypto.h crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h bug.h global.h log.h purge.h cleanup.h packet.h \
limit.h haslimits.h channel.h iptostr.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_auth.c
packet.o: packet.c purge.h cleanup.h trymlock.h packet.h buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet.c
packet_channel_open.o: packet_channel_open.c buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h ssh.h e.h bug.h \
global.h log.h packetparser.h str.h packet.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_channel_open.c
packet_channel_recv.o: packet_channel_recv.c bug.h global.h e.h log.h \
buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h channel.h \
iptostr.h porttostr.h limit.h haslimits.h ssh.h packetparser.h packet.h \
sshcrypto.h crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_channel_recv.c
packet_channel_request.o: packet_channel_request.c buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h ssh.h e.h bug.h \
global.h log.h str.h packetparser.h packet.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_channel_request.c
packet_channel_send.o: packet_channel_send.c bug.h global.h e.h log.h \
buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h channel.h \
iptostr.h porttostr.h limit.h haslimits.h ssh.h packet.h sshcrypto.h \
crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_channel_send.c
packet_get.o: packet_get.c byte.h e.h bug.h global.h log.h \
cryptoint/crypto_uint32.h purge.h cleanup.h ssh.h sshcrypto.h buf.h \
cryptoint/crypto_uint8.h crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint64.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h numtostr.h packet.h limit.h haslimits.h \
channel.h iptostr.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_get.c
packet_hello.o: packet_hello.c buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h byte.h writeall.h purge.h cleanup.h log.h \
str.h getln.h e.h packet.h sshcrypto.h crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint64.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_hello.c
packet_kex.o: packet_kex.c buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h ssh.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h packetparser.h bug.h global.h e.h log.h \
packet.h limit.h haslimits.h channel.h iptostr.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_kex.c
packet_kexdh.o: packet_kexdh.c buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h ssh.h e.h byte.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h packetparser.h bug.h global.h log.h purge.h \
cleanup.h subprocess.h packet.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_kexdh.c
packetparser.o: packetparser.c e.h cryptoint/crypto_uint32.h bug.h \
global.h log.h byte.h packetparser.h cryptoint/crypto_uint8.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packetparser.c
packet_put.o: packet_put.c cryptoint/crypto_uint32.h buf.h \
cryptoint/crypto_uint8.h bug.h global.h e.h log.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h ssh.h packet.h limit.h haslimits.h channel.h \
iptostr.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_put.c
packet_recv.o: packet_recv.c e.h buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h purge.h cleanup.h packet.h sshcrypto.h \
crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_recv.c
packet_send.o: packet_send.c writeall.h e.h byte.h purge.h cleanup.h \
packet.h buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h \
sshcrypto.h crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_send.c
packet_unimplemented.o: packet_unimplemented.c buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h ssh.h log.h \
numtostr.h packet.h sshcrypto.h crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint64.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c packet_unimplemented.c
porttostr.o: porttostr.c cryptoint/crypto_uint16.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c porttostr.c
randombytes.o: randombytes.c randombytes.h haslibrandombytes.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c randombytes.c
randommod.o: randommod.c randombytes.h haslibrandombytes.h randommod.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c randommod.c
readall.o: readall.c e.h readall.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c readall.c
savesync.o: savesync.c open.h savesync.h writeall.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c savesync.c
sc25519.o: sc25519.c cryptoint/crypto_int64.h cryptoint/crypto_uint32.h \
cryptoint/crypto_uint64.h cleanup.h sc25519.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sc25519.c
ssh.o: ssh.c ssh.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c ssh.c
sshcrypto.o: sshcrypto.c purge.h cleanup.h bug.h global.h e.h log.h str.h \
sshcrypto.h buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h \
crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto.c
sshcrypto_cipher.o: sshcrypto_cipher.c crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h \
cryptoint/crypto_uint8.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h stringparser.h e.h log.h bug.h global.h str.h \
byte.h packet.h buf.h sshcrypto.h limit.h haslimits.h channel.h \
iptostr.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_cipher.c
sshcrypto_cipher_chachapoly.o: sshcrypto_cipher_chachapoly.c \
cryptoint/crypto_uint32.h crypto_verify_16.h randommod.h e.h byte.h \
purge.h cleanup.h sshcrypto.h buf.h cryptoint/crypto_uint8.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h bug.h global.h log.h packet.h limit.h \
haslimits.h channel.h iptostr.h porttostr.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_cipher_chachapoly.c
sshcrypto_kex.o: sshcrypto_kex.c crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h \
cryptoint/crypto_uint8.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h stringparser.h str.h byte.h e.h log.h bug.h \
global.h sshcrypto.h buf.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_kex.c
sshcrypto_kex_curve25519.o: sshcrypto_kex_curve25519.c buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h purge.h cleanup.h sshcrypto.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_kex_curve25519.c
sshcrypto_kex_sntrup761x25519.o: sshcrypto_kex_sntrup761x25519.c buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h sshcrypto.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_kex_sntrup761x25519.c
sshcrypto_key.o: sshcrypto_key.c crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h \
cryptoint/crypto_uint8.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h packetparser.h stringparser.h str.h byte.h e.h \
log.h bug.h global.h purge.h cleanup.h sshcrypto.h buf.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_key.c
sshcrypto_key_ed25519.o: sshcrypto_key_ed25519.c crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint32.h \
cryptoint/crypto_uint64.h cryptoint/crypto_uint8.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h packetparser.h buf.h byte.h str.h purge.h \
cleanup.h sshcrypto.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c sshcrypto_key_ed25519.c
str.o: str.c str.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c str.c
stringparser.o: stringparser.c byte.h e.h bug.h global.h log.h \
stringparser.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c stringparser.c
subprocess_auth.o: subprocess_auth.c str.h open.h dropuidgid.h global.h \
e.h log.h sshcrypto.h buf.h cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint64.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h getln.h bug.h limit.h haslimits.h subprocess.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c subprocess_auth.c
subprocess_sign.o: subprocess_sign.c load.h log.h open.h writeall.h \
purge.h cleanup.h global.h bug.h e.h readall.h blocking.h sshcrypto.h \
buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h subprocess.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c subprocess_sign.c
test-crypto.o: test-crypto.c cryptoint/crypto_uint8.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h crypto_declassify.h \
hasvalgrind.h crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h _crypto-test_verify_16.inc \
_crypto-test_verify_32.inc _crypto-test_sort_uint32.inc \
_crypto-test_hash_sha256.inc _crypto-test_hash_sha512.inc \
_crypto-test_sign_ed25519.inc _crypto-test_kem_sntrup761.inc \
_crypto-test_dh_x25519.inc
$(CC) $(CFLAGS) $(CPPFLAGS) -c test-crypto.c
tinysshd.o: tinysshd.c str.h main.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c tinysshd.c
_tinysshd-printkex.o: _tinysshd-printkex.c log.h packet.h buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h ssh.h bug.h global.h e.h packetparser.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-printkex.c
_tinysshd-speed.o: _tinysshd-speed.c crypto.h cryptoint/crypto_int16.h \
cryptoint/crypto_int32.h cryptoint/crypto_int64.h \
cryptoint/crypto_int8.h cryptoint/crypto_uint16.h \
cryptoint/crypto_uint32.h cryptoint/crypto_uint64.h \
cryptoint/crypto_uint8.h crypto_verify_16.h crypto_verify_32.h \
haslibrandombytes.h randombytes.h crypto_hash_sha256.h \
crypto_hash_sha512.h haslib25519.h crypto_kem_sntrup761.h \
haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-speed.c
_tinysshd-test-hello1.o: _tinysshd-test-hello1.c
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-test-hello1.c
_tinysshd-test-hello2.o: _tinysshd-test-hello2.c log.h packet.h buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h global.h str.h writeall.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-test-hello2.c
_tinysshd-test-kex1.o: _tinysshd-test-kex1.c log.h packet.h buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h ssh.h bug.h global.h e.h packetparser.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-test-kex1.c
_tinysshd-test-kex2.o: _tinysshd-test-kex2.c log.h packet.h buf.h \
cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h sshcrypto.h crypto.h \
cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h ssh.h bug.h global.h e.h packetparser.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-test-kex2.c
_tinysshd-unauthenticated.o: _tinysshd-unauthenticated.c log.h packet.h \
buf.h cryptoint/crypto_uint8.h cryptoint/crypto_uint32.h sshcrypto.h \
crypto.h cryptoint/crypto_int16.h cryptoint/crypto_int32.h \
cryptoint/crypto_int64.h cryptoint/crypto_int8.h \
cryptoint/crypto_uint16.h cryptoint/crypto_uint64.h crypto_verify_16.h \
crypto_verify_32.h haslibrandombytes.h randombytes.h \
crypto_hash_sha256.h crypto_hash_sha512.h haslib25519.h \
crypto_kem_sntrup761.h haslibntruprime.h crypto_kem_sntrup761x25519.h \
crypto_onetimeauth_poly1305.h crypto_scalarmult_curve25519.h \
crypto_dh_x25519.h crypto_sign_ed25519.h crypto_sort_uint32.h \
crypto_stream_chacha20.h limit.h haslimits.h channel.h iptostr.h \
porttostr.h ssh.h bug.h global.h e.h packetparser.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c _tinysshd-unauthenticated.c
trymlock.o: trymlock.c hasmlock.h trymlock.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c trymlock.c
uint16_optblocker.o: uint16_optblocker.c cryptoint/crypto_uint16.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c uint16_optblocker.c
uint32_optblocker.o: uint32_optblocker.c cryptoint/crypto_uint32.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c uint32_optblocker.c
uint64_optblocker.o: uint64_optblocker.c cryptoint/crypto_uint64.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c uint64_optblocker.c
uint8_optblocker.o: uint8_optblocker.c cryptoint/crypto_uint8.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c uint8_optblocker.c
writeall.o: writeall.c e.h writeall.h
$(CC) $(CFLAGS) $(CPPFLAGS) -c writeall.c
tinysshd: tinysshd.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o tinysshd tinysshd.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-printkex: _tinysshd-printkex.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-printkex _tinysshd-printkex.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-speed: _tinysshd-speed.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-speed _tinysshd-speed.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-test-hello1: _tinysshd-test-hello1.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-test-hello1 _tinysshd-test-hello1.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-test-hello2: _tinysshd-test-hello2.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-test-hello2 _tinysshd-test-hello2.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-test-kex1: _tinysshd-test-kex1.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-test-kex1 _tinysshd-test-kex1.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-test-kex2: _tinysshd-test-kex2.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-test-kex2 _tinysshd-test-kex2.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
_tinysshd-unauthenticated: _tinysshd-unauthenticated.o $(OBJLIB) randombytes.o libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o _tinysshd-unauthenticated _tinysshd-unauthenticated.o \
$(OBJLIB) $(LDFLAGS) `cat libs` randombytes.o
test-crypto: test-crypto.o $(OBJLIB) libs
$(CC) $(CFLAGS) $(CPPFLAGS) -o test-crypto test-crypto.o \
$(OBJLIB) $(LDFLAGS) `cat libs`
haslib25519.h: tryfeature.sh haslib25519.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh haslib25519.c >haslib25519.h 2>haslib25519.log
cat haslib25519.h
haslibntruprime.h: tryfeature.sh haslibntruprime.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh haslibntruprime.c >haslibntruprime.h 2>haslibntruprime.log
cat haslibntruprime.h
haslibrandombytes.h: tryfeature.sh haslibrandombytes.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh haslibrandombytes.c >haslibrandombytes.h 2>haslibrandombytes.log
cat haslibrandombytes.h
haslibutilh.h: tryfeature.sh haslibutilh.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh haslibutilh.c >haslibutilh.h 2>haslibutilh.log
cat haslibutilh.h
haslimits.h: tryfeature.sh haslimits.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh haslimits.c >haslimits.h 2>haslimits.log
cat haslimits.h
haslogintty.h: tryfeature.sh haslogintty.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh haslogintty.c >haslogintty.h 2>haslogintty.log
cat haslogintty.h
hasmlock.h: tryfeature.sh hasmlock.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasmlock.c >hasmlock.h 2>hasmlock.log
cat hasmlock.h
hasopenpty.h: tryfeature.sh hasopenpty.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasopenpty.c >hasopenpty.h 2>hasopenpty.log
cat hasopenpty.h
hasutilh.h: tryfeature.sh hasutilh.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutilh.c >hasutilh.h 2>hasutilh.log
cat hasutilh.h
hasutmpaddrv6.h: tryfeature.sh hasutmpaddrv6.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpaddrv6.c >hasutmpaddrv6.h 2>hasutmpaddrv6.log
cat hasutmpaddrv6.h
hasutmp.h: tryfeature.sh hasutmp.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmp.c >hasutmp.h 2>hasutmp.log
cat hasutmp.h
hasutmphost.h: tryfeature.sh hasutmphost.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmphost.c >hasutmphost.h 2>hasutmphost.log
cat hasutmphost.h
hasutmploginlogout.h: tryfeature.sh hasutmploginlogout.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmploginlogout.c >hasutmploginlogout.h 2>hasutmploginlogout.log
cat hasutmploginlogout.h
hasutmplogwtmp.h: tryfeature.sh hasutmplogwtmp.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmplogwtmp.c >hasutmplogwtmp.h 2>hasutmplogwtmp.log
cat hasutmplogwtmp.h
hasutmpname.h: tryfeature.sh hasutmpname.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpname.c >hasutmpname.h 2>hasutmpname.log
cat hasutmpname.h
hasutmppid.h: tryfeature.sh hasutmppid.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmppid.c >hasutmppid.h 2>hasutmppid.log
cat hasutmppid.h
hasutmptime.h: tryfeature.sh hasutmptime.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmptime.c >hasutmptime.h 2>hasutmptime.log
cat hasutmptime.h
hasutmptv.h: tryfeature.sh hasutmptv.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmptv.c >hasutmptv.h 2>hasutmptv.log
cat hasutmptv.h
hasutmptype.h: tryfeature.sh hasutmptype.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmptype.c >hasutmptype.h 2>hasutmptype.log
cat hasutmptype.h
hasutmpuser.h: tryfeature.sh hasutmpuser.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpuser.c >hasutmpuser.h 2>hasutmpuser.log
cat hasutmpuser.h
hasutmpxaddrv6.h: tryfeature.sh hasutmpxaddrv6.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpxaddrv6.c >hasutmpxaddrv6.h 2>hasutmpxaddrv6.log
cat hasutmpxaddrv6.h
hasutmpx.h: tryfeature.sh hasutmpx.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpx.c >hasutmpx.h 2>hasutmpx.log
cat hasutmpx.h
hasutmpxsyslen.h: tryfeature.sh hasutmpxsyslen.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpxsyslen.c >hasutmpxsyslen.h 2>hasutmpxsyslen.log
cat hasutmpxsyslen.h
hasutmpxupdwtmpx.h: tryfeature.sh hasutmpxupdwtmpx.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasutmpxupdwtmpx.c >hasutmpxupdwtmpx.h 2>hasutmpxupdwtmpx.log
cat hasutmpxupdwtmpx.h
hasvalgrind.h: tryfeature.sh hasvalgrind.c libs
env CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS) `cat libs`" \
./tryfeature.sh hasvalgrind.c >hasvalgrind.h 2>hasvalgrind.log
cat hasvalgrind.h
test-crypto-dh.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-crypto-dh.sh test-crypto-dh.exp
sh runtest.sh test-crypto-dh.sh test-crypto-dh.out test-crypto-dh.exp
test-crypto-hash.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-crypto-hash.sh test-crypto-hash.exp
sh runtest.sh test-crypto-hash.sh test-crypto-hash.out test-crypto-hash.exp
test-crypto-kem.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-crypto-kem.sh test-crypto-kem.exp
sh runtest.sh test-crypto-kem.sh test-crypto-kem.out test-crypto-kem.exp
test-crypto-sign.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-crypto-sign.sh test-crypto-sign.exp
sh runtest.sh test-crypto-sign.sh test-crypto-sign.out test-crypto-sign.exp
test-crypto-sort.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-crypto-sort.sh test-crypto-sort.exp
sh runtest.sh test-crypto-sort.sh test-crypto-sort.out test-crypto-sort.exp
test-crypto-verify.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-crypto-verify.sh test-crypto-verify.exp
sh runtest.sh test-crypto-verify.sh test-crypto-verify.out test-crypto-verify.exp
test-tinysshd-makekey.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-tinysshd-makekey.sh test-tinysshd-makekey.exp
sh runtest.sh test-tinysshd-makekey.sh test-tinysshd-makekey.out test-tinysshd-makekey.exp
test-tinysshd-printkey.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-tinysshd-printkey.sh test-tinysshd-printkey.exp
sh runtest.sh test-tinysshd-printkey.sh test-tinysshd-printkey.out test-tinysshd-printkey.exp
test-tinysshd.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-tinysshd.sh test-tinysshd.exp
sh runtest.sh test-tinysshd.sh test-tinysshd.out test-tinysshd.exp
test-tinysshnoneauthd.out: $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) runtest.sh test-tinysshnoneauthd.sh test-tinysshnoneauthd.exp
sh runtest.sh test-tinysshnoneauthd.sh test-tinysshnoneauthd.out test-tinysshnoneauthd.exp
test: $(TESTOUT)
libs: trylibs.sh
env CC="$(CC)" ./trylibs.sh -lsocket -lnsl -lutil -lrandombytes -l25519 -lntruprime >libs 2>libs.log
cat libs
tinysshd-makekey: tinysshd
rm -f tinysshd-makekey
ln -s tinysshd tinysshd-makekey
tinysshd-printkey: tinysshd
rm -f tinysshd-printkey
ln -s tinysshd tinysshd-printkey
tinysshnoneauthd: tinysshd
rm -f tinysshnoneauthd
ln -s tinysshd tinysshnoneauthd
install: $(BINARIES) $(LINKS)
mkdir -p $(DESTDIR)$(PREFIX)/sbin
mkdir -p $(DESTDIR)$(PREFIX)/share/man/man8
$(INSTALL) -m 0755 tinysshd $(DESTDIR)$(PREFIX)/sbin/tinysshd
$(INSTALL) -m 0755 tinysshd-makekey $(DESTDIR)$(PREFIX)/sbin/tinysshd-makekey
$(INSTALL) -m 0755 tinysshd-printkey $(DESTDIR)$(PREFIX)/sbin/tinysshd-printkey
$(INSTALL) -m 0755 tinysshnoneauthd $(DESTDIR)$(PREFIX)/sbin/tinysshnoneauthd
$(INSTALL) -m 0644 man/tinysshd.8 $(DESTDIR)$(PREFIX)/share/man/man8/tinysshd.8
$(INSTALL) -m 0644 man/tinysshd-makekey.8 $(DESTDIR)$(PREFIX)/share/man/man8/tinysshd-makekey.8
$(INSTALL) -m 0644 man/tinysshd-printkey.8 $(DESTDIR)$(PREFIX)/share/man/man8/tinysshd-printkey.8
$(INSTALL) -m 0644 man/tinysshnoneauthd.8 $(DESTDIR)$(PREFIX)/share/man/man8/tinysshnoneauthd.8
clean:
rm -f *.log libs $(OBJLIB) $(OBJALL) $(BINARIES) $(TESTCRYPTOBINARIES) $(LINKS) $(AUTOHEADERS) $(TESTOUT)
tinyssh-20250126/README.cryptoint.md 0000664 0000000 0000000 00000000517 14745512304 0016777 0 ustar 00root root 0000000 0000000 Cryptoint is a library created by Daniel J. Bernstein.
It's public-domain code used in SUPERCOP/libntruprime/libmceliece/...
To TinySSH is imported from https://libntruprime.cr.yp.to/libntruprime-20241021/cryptoint.html.
Description from the author e.g. here:
- https://cr.yp.to/talks/2024.07.22/slides-djb-20240722-snippets-4x3.pdf
tinyssh-20250126/README.md 0000664 0000000 0000000 00000005430 14745512304 0014744 0 ustar 00root root 0000000 0000000 ### Introduction ###
* tinysshd is a minimalistic SSH server which implements only a subset of SSHv2 features.
* tinysshd supports only secure cryptography (minimum 128-bit security, protected against cache-timing attacks)
* tinysshd doesn't implement older crypto (such as RSA, DSA, HMAC-MD5, HMAC-SHA1, 3DES, RC4, ...)
* tinysshd doesn't implement unsafe features (such as password or hostbased authentication)
* tinysshd doesn't have features such: SSH1 protocol, compression, port forwarding, agent forwarding, X11 forwarding ...
* tinysshd doesn't use dynamic memory allocation (no allocation failures, etc.)
### Crypto primitives ###
* State-of-the-art crypto: ssh-ed25519, curve25519-sha256, chacha20-poly1305@openssh.com
* Older standard: ecdsa-sha2-nistp256, ecdh-sha2-nistp256, aes256-ctr, hmac-sha2-256 removed in version 20190101
* Postquantum crypto: sntrup761x25519-sha512@openssh.com, chacha20-poly1305@openssh.com
### Project timelime ###
* experimental: 2014.01.01 - 2014.12.31 (experimentation)
* alpha(updated): 2015.01.01 - 2017.12.31 (not ready for production use, ready for testing)
* beta(updated): 2018.01.01 - ????.??.?? (ready for production use)
* stable: expected ????.??.?? - (ready for production use - including post-quantum crypto)
### Current release (20240101) ###
* has 63899 words of code
* beta release
### How-to compile and install ###
~~~
make
sudo make install
~~~
### How-to run ###
~~~
mkdir -p /etc/tinyssh
tinysshd-makekey /etc/tinyssh/sshkeydir
~~~
~~~
TCPSERVER
tcpserver -HRDl0 0.0.0.0 22 /usr/sbin/tinysshd -v /etc/tinyssh/sshkeydir &
BUSYBOX
busybox tcpsvd 0 22 tinysshd -v /etc/tinyssh/sshkeydir &
INETD
/etc/inetd.conf:
ssh stream tcp nowait root /usr/sbin/tinysshd tinysshd -l -v /etc/tinyssh/sshkeydir
SYSTEMD
tinysshd.socket:
[Unit]
Description=TinySSH server socket
ConditionPathExists=!/etc/tinyssh/disable_tinysshd
[Socket]
ListenStream=22
Accept=yes
[Install]
WantedBy=sockets.target
tinysshd@.service:
[Unit]
Description=Tiny SSH server
After=network.target auditd.service
[Service]
ExecStartPre=-/usr/sbin/tinysshd-makekey -q /etc/tinyssh/sshkeydir
EnvironmentFile=-/etc/default/tinysshd
ExecStart=/usr/sbin/tinysshd ${TINYSSHDOPTS} -- /etc/tinyssh/sshkeydir
KillMode=process
SuccessExitStatus=111
StandardInput=socket
StandardError=journal
[Install]
WantedBy=multi-user.target
~~~
tinyssh-20250126/_crypto-test_dh_x25519.inc 0000664 0000000 0000000 00000031557 14745512304 0020235 0 ustar 00root root 0000000 0000000 /* ----- dh/x25519, derived from supercop/crypto_dh/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto_dh_x25519.h"
#define fail ((ok = 0), printf)
static const char *dh_x25519_checksums[] = {
"2c8a73ec86d5d4c4bc838f49cfd78c87b60b534ae6fff59ce3bea0c32cdc1450",
"b09016b3a1371786b46a183085133338159e623c5eb9cbc5eaa4f8b62d6c5aea",
};
static int (*crypto_dh_keypair)(unsigned char *, unsigned char *);
static int (*crypto_dh)(unsigned char *, const unsigned char *,
const unsigned char *);
#define crypto_dh_SECRETKEYBYTES crypto_dh_x25519_SECRETKEYBYTES
#define crypto_dh_PUBLICKEYBYTES crypto_dh_x25519_PUBLICKEYBYTES
#define crypto_dh_BYTES crypto_dh_x25519_BYTES
static void *storage_dh_x25519_a;
static unsigned char *test_dh_x25519_a;
static void *storage_dh_x25519_b;
static unsigned char *test_dh_x25519_b;
static void *storage_dh_x25519_c;
static unsigned char *test_dh_x25519_c;
static void *storage_dh_x25519_d;
static unsigned char *test_dh_x25519_d;
static void *storage_dh_x25519_e;
static unsigned char *test_dh_x25519_e;
static void *storage_dh_x25519_f;
static unsigned char *test_dh_x25519_f;
static void *storage_dh_x25519_a2;
static unsigned char *test_dh_x25519_a2;
static void *storage_dh_x25519_b2;
static unsigned char *test_dh_x25519_b2;
static void *storage_dh_x25519_c2;
static unsigned char *test_dh_x25519_c2;
static void *storage_dh_x25519_d2;
static unsigned char *test_dh_x25519_d2;
static void *storage_dh_x25519_e2;
static unsigned char *test_dh_x25519_e2;
static void *storage_dh_x25519_f2;
static unsigned char *test_dh_x25519_f2;
static void test_dh_x25519_impl(long long impl) {
unsigned char *a = test_dh_x25519_a;
unsigned char *b = test_dh_x25519_b;
unsigned char *c = test_dh_x25519_c;
unsigned char *d = test_dh_x25519_d;
unsigned char *e = test_dh_x25519_e;
unsigned char *f = test_dh_x25519_f;
unsigned char *a2 = test_dh_x25519_a2;
unsigned char *b2 = test_dh_x25519_b2;
unsigned char *c2 = test_dh_x25519_c2;
unsigned char *d2 = test_dh_x25519_d2;
unsigned char *e2 = test_dh_x25519_e2;
unsigned char *f2 = test_dh_x25519_f2;
long long alen = crypto_dh_SECRETKEYBYTES;
long long blen = crypto_dh_SECRETKEYBYTES;
long long clen = crypto_dh_PUBLICKEYBYTES;
long long dlen = crypto_dh_PUBLICKEYBYTES;
long long elen = crypto_dh_BYTES;
long long flen = crypto_dh_BYTES;
if (targetn && atol(targetn) != impl) return;
crypto_dh_keypair = crypto_dh_x25519_keypair;
crypto_dh = crypto_dh_x25519;
for (long long checksumbig = 0; checksumbig < 2; ++checksumbig) {
long long loops = checksumbig ? 512 : 64;
if (checksumbig && valgrind) break;
checksum_clear();
for (long long loop = 0; loop < loops; ++loop) {
output_prepare(c2, c, clen);
output_prepare(a2, a, alen);
crypto_dh_keypair(c, a);
public(c, clen);
public(a, alen);
checksum(c, clen);
checksum(a, alen);
output_compare(c2, c, clen, "crypto_dh_keypair");
output_compare(a2, a, alen, "crypto_dh_keypair");
output_prepare(d2, d, dlen);
output_prepare(b2, b, blen);
crypto_dh_keypair(d, b);
public(d, dlen);
public(b, blen);
checksum(d, dlen);
checksum(b, blen);
output_compare(d2, d, dlen, "crypto_dh_keypair");
output_compare(b2, b, blen, "crypto_dh_keypair");
output_prepare(e2, e, elen);
memcpy(d2, d, dlen);
double_canary(d2, d, dlen);
memcpy(a2, a, alen);
double_canary(a2, a, alen);
secret(d, dlen);
secret(a, alen);
crypto_dh(e, d, a);
public(d, dlen);
public(a, alen);
public(e, elen);
checksum(e, elen);
output_compare(e2, e, elen, "crypto_dh");
input_compare(d2, d, dlen, "crypto_dh");
input_compare(a2, a, alen, "crypto_dh");
double_canary(e2, e, elen);
double_canary(d2, d, dlen);
double_canary(a2, a, alen);
secret(d2, dlen);
secret(a2, alen);
crypto_dh(e2, d2, a2);
public(d2, dlen);
public(a2, alen);
public(e2, elen);
if (memcmp(e2, e, elen) != 0)
fail("failure: crypto_dh is nondeterministic\n");
double_canary(e2, e, elen);
double_canary(d2, d, dlen);
double_canary(a2, a, alen);
secret(d2, dlen);
secret(a, alen);
crypto_dh(d2, d2, a);
public(d2, elen);
public(a, alen);
if (memcmp(d2, e, elen) != 0)
fail("failure: crypto_dh does not handle d=e overlap\n");
memcpy(d2, d, dlen);
secret(d, dlen);
secret(a2, alen);
crypto_dh(a2, d, a2);
public(a2, elen);
public(d, dlen);
if (memcmp(a2, e, elen) != 0)
fail("failure: crypto_dh does not handle a=e overlap\n");
memcpy(a2, a, alen);
output_prepare(f2, f, flen);
memcpy(c2, c, clen);
double_canary(c2, c, clen);
memcpy(b2, b, blen);
double_canary(b2, b, blen);
secret(c, clen);
secret(b, blen);
crypto_dh(f, c, b);
public(c, clen);
public(b, blen);
public(f, flen);
checksum(f, flen);
output_compare(f2, f, flen, "crypto_dh");
input_compare(c2, c, clen, "crypto_dh");
input_compare(b2, b, blen, "crypto_dh");
double_canary(f2, f, flen);
double_canary(c2, c, clen);
double_canary(b2, b, blen);
secret(c2, clen);
secret(b2, blen);
crypto_dh(f2, c2, b2);
public(c2, clen);
public(b2, blen);
public(f2, flen);
if (memcmp(f2, f, flen) != 0)
fail("failure: crypto_dh is nondeterministic\n");
double_canary(f2, f, flen);
double_canary(c2, c, clen);
double_canary(b2, b, blen);
secret(c2, clen);
secret(b, blen);
crypto_dh(c2, c2, b);
public(c2, flen);
public(b, blen);
if (memcmp(c2, f, flen) != 0)
fail("failure: crypto_dh does not handle c=f overlap\n");
memcpy(c2, c, clen);
secret(c, clen);
secret(b2, blen);
crypto_dh(b2, c, b2);
public(b2, flen);
public(c, clen);
if (memcmp(b2, f, flen) != 0)
fail("failure: crypto_dh does not handle b=f overlap\n");
memcpy(b2, b, blen);
if (memcmp(f, e, elen) != 0)
fail("failure: crypto_dh not associative\n");
}
checksum_expected(dh_x25519_checksums[checksumbig]);
}
}
void test_dh_x25519(void) {
long long maxalloc = 0;
if (targeto && strcmp(targeto, "dh")) return;
if (targetp && strcmp(targetp, "x25519")) return;
storage_dh_x25519_a = callocplus(
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES);
test_dh_x25519_a = aligned(storage_dh_x25519_a,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
if (crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES >
maxalloc)
maxalloc = crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES;
storage_dh_x25519_b = callocplus(
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES);
test_dh_x25519_b = aligned(storage_dh_x25519_b,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
if (crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES >
maxalloc)
maxalloc = crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES;
storage_dh_x25519_c = callocplus(
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES);
test_dh_x25519_c = aligned(storage_dh_x25519_c,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
if (crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES >
maxalloc)
maxalloc = crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES;
storage_dh_x25519_d = callocplus(
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES);
test_dh_x25519_d = aligned(storage_dh_x25519_d,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
if (crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES >
maxalloc)
maxalloc = crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES;
storage_dh_x25519_e = callocplus(
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES);
test_dh_x25519_e = aligned(storage_dh_x25519_e,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
if (crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES >
maxalloc)
maxalloc = crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES;
storage_dh_x25519_f = callocplus(
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES);
test_dh_x25519_f = aligned(storage_dh_x25519_f,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
if (crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES + crypto_dh_SECRETKEYBYTES >
maxalloc)
maxalloc = crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES;
storage_dh_x25519_a2 = callocplus(maxalloc);
test_dh_x25519_a2 = aligned(storage_dh_x25519_a2,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
storage_dh_x25519_b2 = callocplus(maxalloc);
test_dh_x25519_b2 = aligned(storage_dh_x25519_b2,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
storage_dh_x25519_c2 = callocplus(maxalloc);
test_dh_x25519_c2 = aligned(storage_dh_x25519_c2,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
storage_dh_x25519_d2 = callocplus(maxalloc);
test_dh_x25519_d2 = aligned(storage_dh_x25519_d2,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
storage_dh_x25519_e2 = callocplus(maxalloc);
test_dh_x25519_e2 = aligned(storage_dh_x25519_e2,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
storage_dh_x25519_f2 = callocplus(maxalloc);
test_dh_x25519_f2 = aligned(storage_dh_x25519_f2,
crypto_dh_BYTES + crypto_dh_PUBLICKEYBYTES +
crypto_dh_SECRETKEYBYTES);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("dh_x25519 offset %lld\n", offset);
forked(test_dh_x25519_impl, -1);
++test_dh_x25519_a;
++test_dh_x25519_b;
++test_dh_x25519_c;
++test_dh_x25519_d;
++test_dh_x25519_e;
++test_dh_x25519_f;
++test_dh_x25519_a2;
++test_dh_x25519_b2;
++test_dh_x25519_c2;
++test_dh_x25519_d2;
++test_dh_x25519_e2;
++test_dh_x25519_f2;
}
free(storage_dh_x25519_f2);
free(storage_dh_x25519_e2);
free(storage_dh_x25519_d2);
free(storage_dh_x25519_c2);
free(storage_dh_x25519_b2);
free(storage_dh_x25519_a2);
free(storage_dh_x25519_f);
free(storage_dh_x25519_e);
free(storage_dh_x25519_d);
free(storage_dh_x25519_c);
free(storage_dh_x25519_b);
free(storage_dh_x25519_a);
}
#undef crypto_dh_SECRETKEYBYTES
#undef crypto_dh_PUBLICKEYBYTES
#undef crypto_dh_BYTES
tinyssh-20250126/_crypto-test_hash_sha256.inc 0000664 0000000 0000000 00000010404 14745512304 0020704 0 ustar 00root root 0000000 0000000 /* ----- hash/sha256, derived from supercop/crypto_hash/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
#define fail ((ok = 0), printf)
static const char *hash_sha256_checksums[] = {
"0fb5122d471d9310c4ff212c64a73cc985f0826484c24f34b56cb1d39534ba24",
"55ff5e29282c4d7d192a20b427c000ec121fcda33dd96d53aa8857e3f2dd1469",
};
static int (*crypto_hash)(unsigned char *, const unsigned char *,
unsigned long long);
#define crypto_hash_BYTES crypto_hash_sha256_BYTES
static void *storage_hash_sha256_h;
static unsigned char *test_hash_sha256_h;
static void *storage_hash_sha256_m;
static unsigned char *test_hash_sha256_m;
static void *storage_hash_sha256_h2;
static unsigned char *test_hash_sha256_h2;
static void *storage_hash_sha256_m2;
static unsigned char *test_hash_sha256_m2;
static void test_hash_sha256_impl(long long impl) {
unsigned char *h = test_hash_sha256_h;
unsigned char *m = test_hash_sha256_m;
unsigned char *h2 = test_hash_sha256_h2;
unsigned char *m2 = test_hash_sha256_m2;
long long hlen = crypto_hash_BYTES;
long long mlen;
if (targetn && atol(targetn) != impl) return;
crypto_hash = crypto_hash_sha256;
for (long long checksumbig = 0; checksumbig < 2; ++checksumbig) {
long long loops = checksumbig ? 512 : 64;
long long maxtest = checksumbig ? 4096 : 128;
if (checksumbig && valgrind) break;
checksum_clear();
for (long long loop = 0; loop < loops; ++loop) {
mlen = myrandom() % (maxtest + 1);
output_prepare(h2, h, hlen);
input_prepare(m2, m, mlen);
secret(m, mlen);
crypto_hash(h, m, mlen);
public(m, mlen);
public(h, hlen);
checksum(h, hlen);
output_compare(h2, h, hlen, "crypto_hash");
input_compare(m2, m, mlen, "crypto_hash");
double_canary(h2, h, hlen);
double_canary(m2, m, mlen);
secret(m2, mlen);
crypto_hash(h2, m2, mlen);
public(m2, mlen);
public(h2, hlen);
if (memcmp(h2, h, hlen) != 0)
fail("failure: crypto_hash is nondeterministic\n");
double_canary(h2, h, hlen);
double_canary(m2, m, mlen);
secret(m2, mlen);
crypto_hash(m2, m2, mlen);
public(m2, hlen);
if (memcmp(m2, h, hlen) != 0)
fail("failure: crypto_hash does not handle m=h overlap\n");
memcpy(m2, m, mlen);
}
checksum_expected(hash_sha256_checksums[checksumbig]);
}
}
void test_hash_sha256(void) {
long long maxalloc = 0;
if (targeto && strcmp(targeto, "hash")) return;
if (targetp && strcmp(targetp, "sha256")) return;
storage_hash_sha256_h = callocplus(crypto_hash_BYTES);
test_hash_sha256_h = aligned(storage_hash_sha256_h, crypto_hash_BYTES);
if (crypto_hash_BYTES > maxalloc) maxalloc = crypto_hash_BYTES;
storage_hash_sha256_m = callocplus(4096 + crypto_hash_BYTES);
test_hash_sha256_m =
aligned(storage_hash_sha256_m, 4096 + crypto_hash_BYTES);
if (4096 + crypto_hash_BYTES > maxalloc)
maxalloc = 4096 + crypto_hash_BYTES;
storage_hash_sha256_h2 = callocplus(maxalloc);
test_hash_sha256_h2 = aligned(storage_hash_sha256_h2, crypto_hash_BYTES);
storage_hash_sha256_m2 = callocplus(maxalloc);
test_hash_sha256_m2 =
aligned(storage_hash_sha256_m2, 4096 + crypto_hash_BYTES);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("hash_sha256 offset %lld\n", offset);
forked(test_hash_sha256_impl, -1);
++test_hash_sha256_h;
++test_hash_sha256_m;
++test_hash_sha256_h2;
++test_hash_sha256_m2;
}
free(storage_hash_sha256_m2);
free(storage_hash_sha256_h2);
free(storage_hash_sha256_m);
free(storage_hash_sha256_h);
}
#undef crypto_hash_BYTES
tinyssh-20250126/_crypto-test_hash_sha512.inc 0000664 0000000 0000000 00000010404 14745512304 0020677 0 ustar 00root root 0000000 0000000 /* ----- hash/sha512, derived from supercop/crypto_hash/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
#define fail ((ok = 0), printf)
static const char *hash_sha512_checksums[] = {
"8220572f58bd4730be165c9739d8d4b0fd2e0229dbe01e25b4aed23f00f23b70",
"c1e322b7cbfc941260c5508967ba05bce22eeee94d425e708b7c3301ea1d5e2e",
};
static int (*crypto_hash)(unsigned char *, const unsigned char *,
unsigned long long);
#define crypto_hash_BYTES crypto_hash_sha512_BYTES
static void *storage_hash_sha512_h;
static unsigned char *test_hash_sha512_h;
static void *storage_hash_sha512_m;
static unsigned char *test_hash_sha512_m;
static void *storage_hash_sha512_h2;
static unsigned char *test_hash_sha512_h2;
static void *storage_hash_sha512_m2;
static unsigned char *test_hash_sha512_m2;
static void test_hash_sha512_impl(long long impl) {
unsigned char *h = test_hash_sha512_h;
unsigned char *m = test_hash_sha512_m;
unsigned char *h2 = test_hash_sha512_h2;
unsigned char *m2 = test_hash_sha512_m2;
long long hlen = crypto_hash_BYTES;
long long mlen;
if (targetn && atol(targetn) != impl) return;
crypto_hash = crypto_hash_sha512;
for (long long checksumbig = 0; checksumbig < 2; ++checksumbig) {
long long loops = checksumbig ? 512 : 64;
long long maxtest = checksumbig ? 4096 : 128;
if (checksumbig && valgrind) break;
checksum_clear();
for (long long loop = 0; loop < loops; ++loop) {
mlen = myrandom() % (maxtest + 1);
output_prepare(h2, h, hlen);
input_prepare(m2, m, mlen);
secret(m, mlen);
crypto_hash(h, m, mlen);
public(m, mlen);
public(h, hlen);
checksum(h, hlen);
output_compare(h2, h, hlen, "crypto_hash");
input_compare(m2, m, mlen, "crypto_hash");
double_canary(h2, h, hlen);
double_canary(m2, m, mlen);
secret(m2, mlen);
crypto_hash(h2, m2, mlen);
public(m2, mlen);
public(h2, hlen);
if (memcmp(h2, h, hlen) != 0)
fail("failure: crypto_hash is nondeterministic\n");
double_canary(h2, h, hlen);
double_canary(m2, m, mlen);
secret(m2, mlen);
crypto_hash(m2, m2, mlen);
public(m2, hlen);
if (memcmp(m2, h, hlen) != 0)
fail("failure: crypto_hash does not handle m=h overlap\n");
memcpy(m2, m, mlen);
}
checksum_expected(hash_sha512_checksums[checksumbig]);
}
}
void test_hash_sha512(void) {
long long maxalloc = 0;
if (targeto && strcmp(targeto, "hash")) return;
if (targetp && strcmp(targetp, "sha512")) return;
storage_hash_sha512_h = callocplus(crypto_hash_BYTES);
test_hash_sha512_h = aligned(storage_hash_sha512_h, crypto_hash_BYTES);
if (crypto_hash_BYTES > maxalloc) maxalloc = crypto_hash_BYTES;
storage_hash_sha512_m = callocplus(4096 + crypto_hash_BYTES);
test_hash_sha512_m =
aligned(storage_hash_sha512_m, 4096 + crypto_hash_BYTES);
if (4096 + crypto_hash_BYTES > maxalloc)
maxalloc = 4096 + crypto_hash_BYTES;
storage_hash_sha512_h2 = callocplus(maxalloc);
test_hash_sha512_h2 = aligned(storage_hash_sha512_h2, crypto_hash_BYTES);
storage_hash_sha512_m2 = callocplus(maxalloc);
test_hash_sha512_m2 =
aligned(storage_hash_sha512_m2, 4096 + crypto_hash_BYTES);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("hash_sha512 offset %lld\n", offset);
forked(test_hash_sha512_impl, -1);
++test_hash_sha512_h;
++test_hash_sha512_m;
++test_hash_sha512_h2;
++test_hash_sha512_m2;
}
free(storage_hash_sha512_m2);
free(storage_hash_sha512_h2);
free(storage_hash_sha512_m);
free(storage_hash_sha512_h);
}
#undef crypto_hash_BYTES
tinyssh-20250126/_crypto-test_kem_sntrup761.inc 0000664 0000000 0000000 00000022602 14745512304 0021321 0 ustar 00root root 0000000 0000000 /* ----- kem/sntrup761, derived from supercop/crypto_kem/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
#define fail ((ok = 0), printf)
static const char *kem_sntrup761_checksums[] = {
"4081ab3f61bac9aae91bff7f9b212855177591ec4427dff2a501be124c5bb97d",
"730a572b64fa05a42bce7b1573edc04b70ef75909db309c012aa27f53f1f2f41",
};
static int (*crypto_kem_keypair)(unsigned char *, unsigned char *);
static int (*crypto_kem_enc)(unsigned char *, unsigned char *,
const unsigned char *);
static int (*crypto_kem_dec)(unsigned char *, const unsigned char *,
const unsigned char *);
#define crypto_kem_SECRETKEYBYTES crypto_kem_sntrup761_SECRETKEYBYTES
#define crypto_kem_PUBLICKEYBYTES crypto_kem_sntrup761_PUBLICKEYBYTES
#define crypto_kem_CIPHERTEXTBYTES crypto_kem_sntrup761_CIPHERTEXTBYTES
#define crypto_kem_BYTES crypto_kem_sntrup761_BYTES
static void *storage_kem_sntrup761_p;
static unsigned char *test_kem_sntrup761_p;
static void *storage_kem_sntrup761_s;
static unsigned char *test_kem_sntrup761_s;
static void *storage_kem_sntrup761_k;
static unsigned char *test_kem_sntrup761_k;
static void *storage_kem_sntrup761_c;
static unsigned char *test_kem_sntrup761_c;
static void *storage_kem_sntrup761_t;
static unsigned char *test_kem_sntrup761_t;
static void *storage_kem_sntrup761_p2;
static unsigned char *test_kem_sntrup761_p2;
static void *storage_kem_sntrup761_s2;
static unsigned char *test_kem_sntrup761_s2;
static void *storage_kem_sntrup761_k2;
static unsigned char *test_kem_sntrup761_k2;
static void *storage_kem_sntrup761_c2;
static unsigned char *test_kem_sntrup761_c2;
static void *storage_kem_sntrup761_t2;
static unsigned char *test_kem_sntrup761_t2;
static void test_kem_sntrup761_impl(long long impl) {
unsigned char *p = test_kem_sntrup761_p;
unsigned char *s = test_kem_sntrup761_s;
unsigned char *k = test_kem_sntrup761_k;
unsigned char *c = test_kem_sntrup761_c;
unsigned char *t = test_kem_sntrup761_t;
unsigned char *p2 = test_kem_sntrup761_p2;
unsigned char *s2 = test_kem_sntrup761_s2;
unsigned char *k2 = test_kem_sntrup761_k2;
unsigned char *c2 = test_kem_sntrup761_c2;
unsigned char *t2 = test_kem_sntrup761_t2;
long long plen = crypto_kem_PUBLICKEYBYTES;
long long slen = crypto_kem_SECRETKEYBYTES;
long long klen = crypto_kem_BYTES;
long long clen = crypto_kem_CIPHERTEXTBYTES;
long long tlen = crypto_kem_BYTES;
if (targetn && atol(targetn) != impl) return;
crypto_kem_keypair = crypto_kem_sntrup761_keypair;
crypto_kem_enc = crypto_kem_sntrup761_enc;
crypto_kem_dec = crypto_kem_sntrup761_dec;
for (long long checksumbig = 0; checksumbig < 2; ++checksumbig) {
long long loops = checksumbig ? 64 : 8;
if (checksumbig && valgrind) break;
checksum_clear();
for (long long loop = 0; loop < loops; ++loop) {
output_prepare(p2, p, plen);
output_prepare(s2, s, slen);
crypto_kem_keypair(p, s);
public(p, plen);
public(s, slen);
checksum(p, plen);
checksum(s, slen);
output_compare(p2, p, plen, "crypto_kem_keypair");
output_compare(s2, s, slen, "crypto_kem_keypair");
output_prepare(c2, c, clen);
output_prepare(k2, k, klen);
memcpy(p2, p, plen);
double_canary(p2, p, plen);
secret(p, plen);
crypto_kem_enc(c, k, p);
public(p, plen);
public(c, clen);
public(k, klen);
checksum(c, clen);
checksum(k, klen);
output_compare(c2, c, clen, "crypto_kem_enc");
output_compare(k2, k, klen, "crypto_kem_enc");
input_compare(p2, p, plen, "crypto_kem_enc");
output_prepare(t2, t, tlen);
memcpy(c2, c, clen);
double_canary(c2, c, clen);
memcpy(s2, s, slen);
double_canary(s2, s, slen);
secret(c, clen);
secret(s, slen);
crypto_kem_dec(t, c, s);
public(c, clen);
public(s, slen);
public(t, tlen);
if (memcmp(t, k, klen) != 0)
fail("failure: crypto_kem_dec does not match k\n");
checksum(t, tlen);
output_compare(t2, t, tlen, "crypto_kem_dec");
input_compare(c2, c, clen, "crypto_kem_dec");
input_compare(s2, s, slen, "crypto_kem_dec");
double_canary(t2, t, tlen);
double_canary(c2, c, clen);
double_canary(s2, s, slen);
secret(c2, clen);
secret(s2, slen);
crypto_kem_dec(t2, c2, s2);
public(c2, clen);
public(s2, slen);
public(t2, tlen);
if (memcmp(t2, t, tlen) != 0)
fail("failure: crypto_kem_dec is nondeterministic\n");
double_canary(t2, t, tlen);
double_canary(c2, c, clen);
double_canary(s2, s, slen);
secret(c2, clen);
secret(s, slen);
crypto_kem_dec(c2, c2, s);
public(c2, tlen);
public(s, slen);
if (memcmp(c2, t, tlen) != 0)
fail("failure: crypto_kem_dec does not handle c=t overlap\n");
memcpy(c2, c, clen);
secret(c, clen);
secret(s2, slen);
crypto_kem_dec(s2, c, s2);
public(s2, tlen);
public(c, clen);
if (memcmp(s2, t, tlen) != 0)
fail("failure: crypto_kem_dec does not handle s=t overlap\n");
memcpy(s2, s, slen);
c[myrandom() % clen] += 1 + (myrandom() % 255);
crypto_kem_dec(t, c, s);
checksum(t, tlen);
c[myrandom() % clen] += 1 + (myrandom() % 255);
crypto_kem_dec(t, c, s);
checksum(t, tlen);
c[myrandom() % clen] += 1 + (myrandom() % 255);
crypto_kem_dec(t, c, s);
checksum(t, tlen);
}
checksum_expected(kem_sntrup761_checksums[checksumbig]);
}
}
void test_kem_sntrup761(void) {
long long maxalloc = 0;
if (targeto && strcmp(targeto, "kem")) return;
if (targetp && strcmp(targetp, "sntrup761")) return;
storage_kem_sntrup761_p = callocplus(crypto_kem_PUBLICKEYBYTES);
test_kem_sntrup761_p =
aligned(storage_kem_sntrup761_p, crypto_kem_PUBLICKEYBYTES);
if (crypto_kem_PUBLICKEYBYTES > maxalloc)
maxalloc = crypto_kem_PUBLICKEYBYTES;
storage_kem_sntrup761_s = callocplus(crypto_kem_SECRETKEYBYTES);
test_kem_sntrup761_s =
aligned(storage_kem_sntrup761_s, crypto_kem_SECRETKEYBYTES);
if (crypto_kem_SECRETKEYBYTES > maxalloc)
maxalloc = crypto_kem_SECRETKEYBYTES;
storage_kem_sntrup761_k = callocplus(crypto_kem_BYTES);
test_kem_sntrup761_k = aligned(storage_kem_sntrup761_k, crypto_kem_BYTES);
if (crypto_kem_BYTES > maxalloc) maxalloc = crypto_kem_BYTES;
storage_kem_sntrup761_c = callocplus(crypto_kem_CIPHERTEXTBYTES);
test_kem_sntrup761_c =
aligned(storage_kem_sntrup761_c, crypto_kem_CIPHERTEXTBYTES);
if (crypto_kem_CIPHERTEXTBYTES > maxalloc)
maxalloc = crypto_kem_CIPHERTEXTBYTES;
storage_kem_sntrup761_t = callocplus(crypto_kem_BYTES);
test_kem_sntrup761_t = aligned(storage_kem_sntrup761_t, crypto_kem_BYTES);
if (crypto_kem_BYTES > maxalloc) maxalloc = crypto_kem_BYTES;
storage_kem_sntrup761_p2 = callocplus(maxalloc);
test_kem_sntrup761_p2 =
aligned(storage_kem_sntrup761_p2, crypto_kem_PUBLICKEYBYTES);
storage_kem_sntrup761_s2 = callocplus(maxalloc);
test_kem_sntrup761_s2 =
aligned(storage_kem_sntrup761_s2, crypto_kem_SECRETKEYBYTES);
storage_kem_sntrup761_k2 = callocplus(maxalloc);
test_kem_sntrup761_k2 = aligned(storage_kem_sntrup761_k2, crypto_kem_BYTES);
storage_kem_sntrup761_c2 = callocplus(maxalloc);
test_kem_sntrup761_c2 =
aligned(storage_kem_sntrup761_c2, crypto_kem_CIPHERTEXTBYTES);
storage_kem_sntrup761_t2 = callocplus(maxalloc);
test_kem_sntrup761_t2 = aligned(storage_kem_sntrup761_t2, crypto_kem_BYTES);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("kem_sntrup761 offset %lld\n", offset);
forked(test_kem_sntrup761_impl, -1);
++test_kem_sntrup761_p;
++test_kem_sntrup761_s;
++test_kem_sntrup761_k;
++test_kem_sntrup761_c;
++test_kem_sntrup761_t;
++test_kem_sntrup761_p2;
++test_kem_sntrup761_s2;
++test_kem_sntrup761_k2;
++test_kem_sntrup761_c2;
++test_kem_sntrup761_t2;
}
free(storage_kem_sntrup761_t2);
free(storage_kem_sntrup761_c2);
free(storage_kem_sntrup761_k2);
free(storage_kem_sntrup761_s2);
free(storage_kem_sntrup761_p2);
free(storage_kem_sntrup761_t);
free(storage_kem_sntrup761_c);
free(storage_kem_sntrup761_k);
free(storage_kem_sntrup761_s);
free(storage_kem_sntrup761_p);
}
#undef crypto_kem_SECRETKEYBYTES
#undef crypto_kem_PUBLICKEYBYTES
#undef crypto_kem_CIPHERTEXTBYTES
#undef crypto_kem_BYTES
tinyssh-20250126/_crypto-test_sign_ed25519.inc 0000664 0000000 0000000 00000033524 14745512304 0020717 0 ustar 00root root 0000000 0000000 /* ----- sign/ed25519, derived from supercop/crypto_sign/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
#define fail ((ok = 0), printf)
static const char *sign_ed25519_checksums[] = {
"ce11fd7c1eac4dd0bc5eec49b26ad1e91aef696fae50ce377dbd806dc394da01",
"2ed857f17c917a8185e6c296303a11772ae45683a5e7cb5b095489bad65fffde",
};
static int (*crypto_sign_keypair)(unsigned char *, unsigned char *);
static int (*crypto_sign)(unsigned char *, unsigned long long *,
const unsigned char *, unsigned long long,
const unsigned char *);
static int (*crypto_sign_open)(unsigned char *, unsigned long long *,
const unsigned char *, unsigned long long,
const unsigned char *);
#define crypto_sign_SECRETKEYBYTES crypto_sign_ed25519_SECRETKEYBYTES
#define crypto_sign_PUBLICKEYBYTES crypto_sign_ed25519_PUBLICKEYBYTES
#define crypto_sign_BYTES crypto_sign_ed25519_BYTES
static void *storage_sign_ed25519_p;
static unsigned char *test_sign_ed25519_p;
static void *storage_sign_ed25519_s;
static unsigned char *test_sign_ed25519_s;
static void *storage_sign_ed25519_m;
static unsigned char *test_sign_ed25519_m;
static void *storage_sign_ed25519_c;
static unsigned char *test_sign_ed25519_c;
static void *storage_sign_ed25519_t;
static unsigned char *test_sign_ed25519_t;
static void *storage_sign_ed25519_p2;
static unsigned char *test_sign_ed25519_p2;
static void *storage_sign_ed25519_s2;
static unsigned char *test_sign_ed25519_s2;
static void *storage_sign_ed25519_m2;
static unsigned char *test_sign_ed25519_m2;
static void *storage_sign_ed25519_c2;
static unsigned char *test_sign_ed25519_c2;
static void *storage_sign_ed25519_t2;
static unsigned char *test_sign_ed25519_t2;
static void test_sign_ed25519_impl(long long impl) {
unsigned char *p = test_sign_ed25519_p;
unsigned char *s = test_sign_ed25519_s;
unsigned char *m = test_sign_ed25519_m;
unsigned char *c = test_sign_ed25519_c;
unsigned char *t = test_sign_ed25519_t;
unsigned char *p2 = test_sign_ed25519_p2;
unsigned char *s2 = test_sign_ed25519_s2;
unsigned char *m2 = test_sign_ed25519_m2;
unsigned char *c2 = test_sign_ed25519_c2;
unsigned char *t2 = test_sign_ed25519_t2;
unsigned long long plen = crypto_sign_PUBLICKEYBYTES;
unsigned long long slen = crypto_sign_SECRETKEYBYTES;
unsigned long long mlen;
unsigned long long clen;
unsigned long long tlen;
if (targetn && atol(targetn) != impl) return;
crypto_sign_keypair = crypto_sign_ed25519_keypair;
crypto_sign = crypto_sign_ed25519;
crypto_sign_open = crypto_sign_ed25519_open;
for (long long checksumbig = 0; checksumbig < 2; ++checksumbig) {
long long loops = checksumbig ? 64 : 8;
long long maxtest = checksumbig ? 4096 : 128;
if (checksumbig && valgrind) break;
checksum_clear();
for (long long loop = 0; loop < loops; ++loop) {
int result;
mlen = myrandom() % (maxtest + 1);
output_prepare(p2, p, plen);
output_prepare(s2, s, slen);
crypto_sign_keypair(p, s);
public(p, plen);
public(s, slen);
checksum(p, plen);
checksum(s, slen);
output_compare(p2, p, plen, "crypto_sign_keypair");
output_compare(s2, s, slen, "crypto_sign_keypair");
clen = mlen + crypto_sign_BYTES;
output_prepare(c2, c, clen);
input_prepare(m2, m, mlen);
memcpy(s2, s, slen);
double_canary(s2, s, slen);
secret(m, mlen);
secret(s, slen);
crypto_sign(c, &clen, m, mlen, s);
public(m, mlen);
public(s, slen);
public(c, clen);
if (clen < mlen)
fail(
"failure: crypto_sign returns smaller output than input\n");
if (clen > mlen + crypto_sign_BYTES)
fail("failure: crypto_sign returns more than crypto_sign_BYTES "
"extra bytes\n");
checksum(c, clen);
output_compare(c2, c, clen, "crypto_sign");
input_compare(m2, m, mlen, "crypto_sign");
input_compare(s2, s, slen, "crypto_sign");
tlen = clen;
output_prepare(t2, t, tlen);
memcpy(c2, c, clen);
double_canary(c2, c, clen);
memcpy(p2, p, plen);
double_canary(p2, p, plen);
public(c, clen);
public(p, plen);
result = crypto_sign_open(t, &tlen, c, clen, p);
public(&result, sizeof result);
if (result != 0)
fail("failure: crypto_sign_open returns nonzero\n");
public(c, clen);
public(p, plen);
public(t, tlen);
if (tlen != mlen)
fail("failure: crypto_sign_open does not match mlen\n");
if (memcmp(t, m, mlen) != 0)
fail("failure: crypto_sign_open does not match m\n");
checksum(t, tlen);
output_compare(t2, t, clen, "crypto_sign_open");
input_compare(c2, c, clen, "crypto_sign_open");
input_compare(p2, p, plen, "crypto_sign_open");
double_canary(t2, t, tlen);
double_canary(c2, c, clen);
double_canary(p2, p, plen);
public(c2, clen);
public(p2, plen);
result = crypto_sign_open(t2, &tlen, c2, clen, p2);
public(&result, sizeof result);
if (result != 0)
fail("failure: crypto_sign_open returns nonzero\n");
public(c2, clen);
public(p2, plen);
public(t2, tlen);
if (memcmp(t2, t, tlen) != 0)
fail("failure: crypto_sign_open is nondeterministic\n");
double_canary(t2, t, tlen);
double_canary(c2, c, clen);
double_canary(p2, p, plen);
public(c2, clen);
public(p, plen);
result = crypto_sign_open(c2, &tlen, c2, clen, p);
public(&result, sizeof result);
if (result != 0)
fail("failure: crypto_sign_open with c=t overlap returns "
"nonzero\n");
public(c2, tlen);
public(p, plen);
if (memcmp(c2, t, tlen) != 0)
fail("failure: crypto_sign_open does not handle c=t overlap\n");
memcpy(c2, c, clen);
public(c, clen);
public(p2, plen);
result = crypto_sign_open(p2, &tlen, c, clen, p2);
public(&result, sizeof result);
if (result != 0)
fail("failure: crypto_sign_open with p=t overlap returns "
"nonzero\n");
public(p2, tlen);
public(c, clen);
if (memcmp(p2, t, tlen) != 0)
fail("failure: crypto_sign_open does not handle p=t overlap\n");
memcpy(p2, p, plen);
c[myrandom() % clen] += 1 + (myrandom() % 255);
if (crypto_sign_open(t, &tlen, c, clen, p) == 0)
if ((tlen != mlen) || (memcmp(t, m, mlen) != 0))
fail(
"failure: crypto_sign_open allows trivial forgeries\n");
c[myrandom() % clen] += 1 + (myrandom() % 255);
if (crypto_sign_open(t, &tlen, c, clen, p) == 0)
if ((tlen != mlen) || (memcmp(t, m, mlen) != 0))
fail(
"failure: crypto_sign_open allows trivial forgeries\n");
c[myrandom() % clen] += 1 + (myrandom() % 255);
if (crypto_sign_open(t, &tlen, c, clen, p) == 0)
if ((tlen != mlen) || (memcmp(t, m, mlen) != 0))
fail(
"failure: crypto_sign_open allows trivial forgeries\n");
}
checksum_expected(sign_ed25519_checksums[checksumbig]);
}
}
void test_sign_ed25519(void) {
long long maxalloc = 0;
if (targeto && strcmp(targeto, "sign")) return;
if (targetp && strcmp(targetp, "ed25519")) return;
storage_sign_ed25519_p =
callocplus(4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
test_sign_ed25519_p =
aligned(storage_sign_ed25519_p, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
if (4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES >
maxalloc)
maxalloc = 4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES;
storage_sign_ed25519_s =
callocplus(4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
test_sign_ed25519_s =
aligned(storage_sign_ed25519_s, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
if (4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES >
maxalloc)
maxalloc = 4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES;
storage_sign_ed25519_m =
callocplus(4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
test_sign_ed25519_m =
aligned(storage_sign_ed25519_m, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
if (4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES >
maxalloc)
maxalloc = 4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES;
storage_sign_ed25519_c =
callocplus(4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
test_sign_ed25519_c =
aligned(storage_sign_ed25519_c, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
if (4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES >
maxalloc)
maxalloc = 4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES;
storage_sign_ed25519_t =
callocplus(4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
test_sign_ed25519_t =
aligned(storage_sign_ed25519_t, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
if (4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES >
maxalloc)
maxalloc = 4096 + crypto_sign_BYTES + crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES;
storage_sign_ed25519_p2 = callocplus(maxalloc);
test_sign_ed25519_p2 =
aligned(storage_sign_ed25519_p2, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
storage_sign_ed25519_s2 = callocplus(maxalloc);
test_sign_ed25519_s2 =
aligned(storage_sign_ed25519_s2, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
storage_sign_ed25519_m2 = callocplus(maxalloc);
test_sign_ed25519_m2 =
aligned(storage_sign_ed25519_m2, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
storage_sign_ed25519_c2 = callocplus(maxalloc);
test_sign_ed25519_c2 =
aligned(storage_sign_ed25519_c2, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
storage_sign_ed25519_t2 = callocplus(maxalloc);
test_sign_ed25519_t2 =
aligned(storage_sign_ed25519_t2, 4096 + crypto_sign_BYTES +
crypto_sign_PUBLICKEYBYTES +
crypto_sign_SECRETKEYBYTES);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("sign_ed25519 offset %lld\n", offset);
forked(test_sign_ed25519_impl, -1);
++test_sign_ed25519_p;
++test_sign_ed25519_s;
++test_sign_ed25519_m;
++test_sign_ed25519_c;
++test_sign_ed25519_t;
++test_sign_ed25519_p2;
++test_sign_ed25519_s2;
++test_sign_ed25519_m2;
++test_sign_ed25519_c2;
++test_sign_ed25519_t2;
}
free(storage_sign_ed25519_t2);
free(storage_sign_ed25519_c2);
free(storage_sign_ed25519_m2);
free(storage_sign_ed25519_s2);
free(storage_sign_ed25519_p2);
free(storage_sign_ed25519_t);
free(storage_sign_ed25519_c);
free(storage_sign_ed25519_m);
free(storage_sign_ed25519_s);
free(storage_sign_ed25519_p);
}
#undef crypto_sign_SECRETKEYBYTES
#undef crypto_sign_PUBLICKEYBYTES
#undef crypto_sign_BYTES
tinyssh-20250126/_crypto-test_sort_uint32.inc 0000664 0000000 0000000 00000006415 14745512304 0021073 0 ustar 00root root 0000000 0000000 /* ----- sort/uint32, derived from supercop/crypto_sort/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
#define fail ((ok = 0), printf)
static const char *sort_uint32_checksums[] = {
"83fc714d7acc0375aa6657bd36d3324a6cbc503f68019345651be8a88534c3e2",
"30921a0be2d73a185181f0ec842fa0fa73cd6e958fc03411d435f14a3fc64c89",
};
static void (*crypto_sort)(void *, long long);
#define crypto_sort_BYTES crypto_sort_uint32_BYTES
static void *storage_sort_uint32_x;
static unsigned char *test_sort_uint32_x;
static void *storage_sort_uint32_x2;
static unsigned char *test_sort_uint32_x2;
static void test_sort_uint32_impl(long long impl) {
unsigned char *x = test_sort_uint32_x;
unsigned char *x2 = test_sort_uint32_x2;
long long xlen;
long long xwords;
if (targetn && atol(targetn) != impl) return;
crypto_sort = crypto_sort_uint32;
for (long long checksumbig = 0; checksumbig < 2; ++checksumbig) {
long long loops = checksumbig ? 4096 : 1024;
long long maxtest = checksumbig ? 4096 : 128;
if (checksumbig && valgrind) break;
checksum_clear();
for (long long loop = 0; loop < loops; ++loop) {
xwords = myrandom() % (maxtest + 1);
xlen = xwords * crypto_sort_BYTES;
input_prepare(x2, x, xlen);
endianness(x, xwords, crypto_sort_BYTES);
secret(x, xlen);
crypto_sort(x, xwords);
public(x, xlen);
endianness(x, xwords, crypto_sort_BYTES);
checksum(x, xlen);
output_compare(x2, x, xlen, "crypto_sort");
double_canary(x2, x, xlen);
endianness(x2, xwords, crypto_sort_BYTES);
secret(x2, xlen);
crypto_sort(x2, xwords);
public(x2, xlen);
endianness(x2, xwords, crypto_sort_BYTES);
if (memcmp(x2, x, xlen) != 0)
fail("failure: crypto_sort is nondeterministic\n");
}
checksum_expected(sort_uint32_checksums[checksumbig]);
}
}
void test_sort_uint32(void) {
long long maxalloc = 0;
if (targeto && strcmp(targeto, "sort")) return;
if (targetp && strcmp(targetp, "uint32")) return;
storage_sort_uint32_x = callocplus(crypto_sort_uint32_BYTES * 4096);
test_sort_uint32_x =
aligned(storage_sort_uint32_x, crypto_sort_uint32_BYTES * 4096);
if (crypto_sort_uint32_BYTES * 4096 > maxalloc)
maxalloc = crypto_sort_uint32_BYTES * 4096;
storage_sort_uint32_x2 = callocplus(maxalloc);
test_sort_uint32_x2 =
aligned(storage_sort_uint32_x2, crypto_sort_uint32_BYTES * 4096);
for (long long offset = 0; offset < 1; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("sort_uint32 offset %lld\n", offset);
forked(test_sort_uint32_impl, -1);
++test_sort_uint32_x;
++test_sort_uint32_x2;
}
free(storage_sort_uint32_x2);
free(storage_sort_uint32_x);
}
#undef crypto_sort_BYTES
tinyssh-20250126/_crypto-test_verify_16.inc 0000664 0000000 0000000 00000004007 14745512304 0020505 0 ustar 00root root 0000000 0000000 /* ----- verify, derived from supercop/crypto_verify/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
static unsigned char *test_verify_16_x;
static unsigned char *test_verify_16_y;
static void test_verify_16_check(void) {
unsigned char *x = test_verify_16_x;
unsigned char *y = test_verify_16_y;
int r;
secret(x, 16);
secret(y, 16);
r = crypto_verify_16(x, y);
public(x, 16);
public(y, 16);
public(&r, sizeof r);
if (r == 0) {
if (memcmp(x, y, 16)) fail("failure: different strings pass verify\n");
}
else if (r == -1) {
if (!memcmp(x, y, 16)) fail("failure: equal strings fail verify\n");
}
else { fail("failure: weird return value\n"); }
}
void test_verify_16_impl(long long impl) {
unsigned char *x = test_verify_16_x;
unsigned char *y = test_verify_16_y;
if (targetn && atol(targetn) != impl) return;
randombytes(x, 16);
randombytes(y, 16);
test_verify_16_check();
memcpy(y, x, 16);
test_verify_16_check();
y[myrandom() % 16] = myrandom();
test_verify_16_check();
y[myrandom() % 16] = myrandom();
test_verify_16_check();
y[myrandom() % 16] = myrandom();
test_verify_16_check();
}
static void test_verify_16(void) {
if (targeto && strcmp(targeto, "verify")) return;
if (targetp && strcmp(targetp, "16")) return;
test_verify_16_x = callocplus(16);
test_verify_16_y = callocplus(16);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("verify_16 offset %lld\n", offset);
forked(test_verify_16_impl, -1);
++test_verify_16_x;
++test_verify_16_y;
}
}
tinyssh-20250126/_crypto-test_verify_32.inc 0000664 0000000 0000000 00000004007 14745512304 0020503 0 ustar 00root root 0000000 0000000 /* ----- verify, derived from supercop/crypto_verify/try.c */
/*
derived from djb work from lib25519/libntruprime
mj modifications:
- rename files to test-crypto.c and _crypto_<>.<>.inc
- fix compiler warnings
- include crypto.h
- use less rounds for valgrind test
- reformat using clang-format
*/
#include
#include
#include
#include
#include "crypto.h"
static unsigned char *test_verify_32_x;
static unsigned char *test_verify_32_y;
static void test_verify_32_check(void) {
unsigned char *x = test_verify_32_x;
unsigned char *y = test_verify_32_y;
int r;
secret(x, 32);
secret(y, 32);
r = crypto_verify_32(x, y);
public(x, 32);
public(y, 32);
public(&r, sizeof r);
if (r == 0) {
if (memcmp(x, y, 32)) fail("failure: different strings pass verify\n");
}
else if (r == -1) {
if (!memcmp(x, y, 32)) fail("failure: equal strings fail verify\n");
}
else { fail("failure: weird return value\n"); }
}
void test_verify_32_impl(long long impl) {
unsigned char *x = test_verify_32_x;
unsigned char *y = test_verify_32_y;
if (targetn && atol(targetn) != impl) return;
randombytes(x, 32);
randombytes(y, 32);
test_verify_32_check();
memcpy(y, x, 32);
test_verify_32_check();
y[myrandom() % 32] = myrandom();
test_verify_32_check();
y[myrandom() % 32] = myrandom();
test_verify_32_check();
y[myrandom() % 32] = myrandom();
test_verify_32_check();
}
static void test_verify_32(void) {
if (targeto && strcmp(targeto, "verify")) return;
if (targetp && strcmp(targetp, "32")) return;
test_verify_32_x = callocplus(32);
test_verify_32_y = callocplus(32);
for (long long offset = 0; offset < 2; ++offset) {
if (targetoffset && atol(targetoffset) != offset) continue;
if (offset && valgrind) break;
printf("verify_32 offset %lld\n", offset);
forked(test_verify_32_impl, -1);
++test_verify_32_x;
++test_verify_32_y;
}
}
tinyssh-20250126/_tinysshd-printkex.c 0000664 0000000 0000000 00000010341 14745512304 0017474 0 ustar 00root root 0000000 0000000 /*
20141210
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include "log.h"
#include "packet.h"
#include "ssh.h"
#include "bug.h"
#include "packetparser.h"
#include "global.h"
static void cleanup(void) {
global_purge();
}
__attribute__((noreturn))
static void die_fatal(const char *trouble, const char *d, const char *fn) {
cleanup();
if (d) {
if (fn) log_f5(trouble, " ", d, "/", fn);
else log_f3(trouble, " ", d);
}
else {
log_f1(trouble);
}
_exit(111);
}
static int packet_kex_receive_(void) {
struct buf *b = &packet.kexrecv;
long long pos = 0;
crypto_uint8 ch;
crypto_uint32 len;
if (!packet_getall(b, SSH_MSG_KEXINIT)) return 0;
/* parse packet */
pos = packetparser_uint8(b->buf, b->len, pos, &ch); /* SSH_MSG_KEXINIT */
if (ch != SSH_MSG_KEXINIT) bug_proto();
pos = packetparser_skip(b->buf, b->len, pos, 16); /* cookie */
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* kex algorithms */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("kex algorithms: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* server host key algorithms */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("server host key algorithms: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* encryption algorithms client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("encryption algorithms client to server: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* encryption algorithms server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("encryption algorithms server to client: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* mac algorithms client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("mac algorithms client to server: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* mac algorithms server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("mac algorithms server to client: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* compress algorithms client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* compress algorithms server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* languages client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* languages server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint8(b->buf, b->len, pos, &ch); /* kex first packet follows */
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* reserved */
return 1;
}
int main(int argc, char **argv) {
pid_t pid;
int tochild[2] = { -1, -1 };
int fromchild[2] = { -1, -1 };
if (argc < 2) _exit(111);
if (!argv[0]) _exit(111);
if (!argv[1]) _exit(111);
++argv;
if (pipe(tochild) == -1) _exit(111);
if (pipe(fromchild) == -1) _exit(111);
pid = fork();
if (pid == -1) _exit(111);
if (pid == 0) {
close(tochild[1]);
close(fromchild[0]);
close(2);
if (dup2(tochild[0], 0) == -1) _exit(111);
if (dup2(fromchild[1], 1) == -1) _exit(111);
execvp(*argv, argv);
_exit(111);
}
close(tochild[0]);
close(fromchild[1]);
close(0); if (dup2(fromchild[0], 0) == -1) _exit(111);
close(1); if (dup2(tochild[1], 1) == -1) _exit(111);
signal(SIGPIPE, SIG_IGN);
global_init();
log_init(2, "_tinysshd-printkex", 0, 0);
if (!packet_hello_receive()) die_fatal("unable to receive hello-string", 0, 0);
if (!packet_hello_send()) die_fatal("unable to send hello-string", 0, 0);
if (!packet_kex_receive_()) die_fatal("unable to receive kex-message", 0, 0);
_exit(111);
}
tinyssh-20250126/_tinysshd-speed.c 0000664 0000000 0000000 00000016042 14745512304 0016734 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include "crypto.h"
static unsigned char sk[2560];
static unsigned char pk[2560];
static unsigned char a[16];
static unsigned char n[8];
static unsigned char k[64];
static unsigned char h[64];
static unsigned char space[10240];
static unsigned char m[51200];
static unsigned char sm[51200];
static unsigned long long smlen;
static unsigned long long mlen;
static const char *implementation, *version;
static int flagtimeout;
static void timeout(int x) {
flagtimeout = x = 1;
signal(SIGALRM, timeout);
}
int main(void) {
long long count;
signal(SIGALRM, timeout);
/* randombytes test */
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
randombytes(space, sizeof space);
++count;
}
printf("randombytes: %lld MB/s (%s)\n", count / 100, randombytes_source());
#ifdef crypto_hash_sha512_IMPLEMENTATION
implementation = crypto_hash_sha512_IMPLEMENTATION;
#else
implementation = "unknown";
#endif
#ifdef crypto_hash_sha512_VERSION
version = crypto_hash_sha512_VERSION;
#else
version = "unknown";
#endif
/* sha512 test */
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_hash_sha512(h, space, sizeof space) != 0) return 111;
++count;
}
printf("crypto_hash_sha512: %lld MB/s (%s, %s)\n", count / 100,
implementation, version);
#ifdef crypto_hash_sha256_IMPLEMENTATION
implementation = crypto_hash_sha256_IMPLEMENTATION;
#else
implementation = "unknown";
#endif
#ifdef crypto_hash_sha256_VERSION
version = crypto_hash_sha256_VERSION;
#else
version = "unknown";
#endif
/* sha256 test */
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_hash_sha256(h, space, sizeof space) != 0) return 111;
++count;
}
printf("crypto_hash_sha256: %lld MB/s (%s, %s)\n", count / 100,
implementation, version);
#ifdef crypto_stream_chacha20_IMPLEMENTATION
implementation = crypto_stream_chacha20_IMPLEMENTATION;
#else
implementation = "unknown";
#endif
#ifdef crypto_stream_chacha20_VERSION
version = crypto_stream_chacha20_VERSION;
#else
version = "unknown";
#endif
/* chacha20 test */
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_stream_chacha20_xor(space, space, sizeof space, n, k) != 0)
return 111;
++count;
}
printf("crypto_stream_chacha20_xor: %lld MB/s (%s, %s)\n", count / 100,
implementation, version);
#ifdef crypto_onetimeauth_poly1305_IMPLEMENTATION
implementation = crypto_onetimeauth_poly1305_IMPLEMENTATION;
#else
implementation = "unknown";
#endif
#ifdef crypto_onetimeauth_poly1305_VERSION
version = crypto_onetimeauth_poly1305_VERSION;
#else
version = "unknown";
#endif
/* onetimeauth test */
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_onetimeauth_poly1305(a, space, sizeof space, k) != 0)
return 111;
++count;
}
printf("crypto_onetimeauth_poly1305: %lld MB/s (%s, %s)\n", count / 100,
implementation, version);
#ifdef crypto_scalarmult_curve25519_IMPLEMENTATION
implementation = crypto_scalarmult_curve25519_IMPLEMENTATION;
#else
implementation = "unknown";
#endif
#ifdef crypto_scalarmult_curve25519_VERSION
version = crypto_scalarmult_curve25519_VERSION;
#else
version = "unknown";
#endif
/* x25519 test */
randombytes(sk, crypto_scalarmult_curve25519_SCALARBYTES);
crypto_scalarmult_curve25519_base(pk, sk);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_scalarmult_curve25519(k, sk, pk) != 0) return 111;
++count;
}
printf("crypto_scalarmult_curve25519: %lld dh/s (%s, %s)\n", count,
implementation, version);
#ifdef crypto_sign_ed25519_IMPLEMENTATION
implementation = crypto_sign_ed25519_IMPLEMENTATION;
#else
implementation = "unknown";
#endif
#ifdef crypto_sign_ed25519_VERSION
version = crypto_sign_ed25519_VERSION;
#else
version = "unknown";
#endif
/* ed25519 test */
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_sign_ed25519_keypair(pk, sk) != 0) return 111;
++count;
}
printf("crypto_sign_ed25519_keypair: %lld keypairs/s (%s, %s)\n", count,
implementation, version);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_sign_ed25519(sm, &smlen, m + crypto_sign_ed25519_BYTES,
sizeof(m) - crypto_sign_ed25519_BYTES, sk) != 0)
return 111;
++count;
}
printf("crypto_sign_ed25519: %lld sigs/s (%s, %s)\n", count, implementation,
version);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_sign_ed25519_open(m, &mlen, sm, sizeof sm, pk) != 0)
return 111;
++count;
}
printf("crypto_sign_ed25519_open: %lld sigs/s (%s, %s)\n", count,
implementation, version);
#ifdef crypto_kem_sntrup4591761_IMPLEMENTATION
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_kem_sntrup4591761_keypair(pk, sk) != 0) return 111;
++count;
}
printf("crypto_kem_sntrup4591761_keypair: %lld keypairs/s (%s)\n", count,
crypto_kem_sntrup4591761_IMPLEMENTATION);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_kem_sntrup4591761_enc(c, k, pk) != 0) return 111;
++count;
}
printf("crypto_kem_sntrup4591761_enc: %lld encryptions/s (%s)\n", count,
crypto_kem_sntrup4591761_IMPLEMENTATION);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_kem_sntrup4591761_dec(k, c, sk) != 0) return 111;
++count;
}
printf("crypto_kem_sntrup4591761_dec: %lld decryptions/s (%s)\n", count,
crypto_kem_sntrup4591761_IMPLEMENTATION);
#endif
#ifdef crypto_kem_sntrup4591761x25519_IMPLEMENTATION
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_kem_sntrup4591761x25519_keypair(pk, sk) != 0) return 111;
++count;
}
printf("crypto_kem_sntrup4591761x25519_keypair: %lld keypairs/s (%s)\n",
count, crypto_kem_sntrup4591761x25519_IMPLEMENTATION);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_kem_sntrup4591761x25519_enc(c, k, pk) != 0) return 111;
++count;
}
printf("crypto_kem_sntrup4591761x25519_enc: %lld encryptions/s (%s)\n",
count, crypto_kem_sntrup4591761x25519_IMPLEMENTATION);
alarm(1);
flagtimeout = 0;
count = 0;
while (!flagtimeout) {
if (crypto_kem_sntrup4591761x25519_dec(k, c, sk) != 0) return 111;
++count;
}
printf("crypto_kem_sntrup4591761x25519_dec: %lld decryptions/s (%s)\n",
count, crypto_kem_sntrup4591761x25519_IMPLEMENTATION);
#endif
return 0;
}
tinyssh-20250126/_tinysshd-test-hello1.c 0000664 0000000 0000000 00000001710 14745512304 0017771 0 ustar 00root root 0000000 0000000 /*
20160225
Jan Mojzis
Public domain.
*/
#include
#include
#include
int main(int argc, char **argv) {
pid_t pid;
int tochild[2] = {-1, -1};
int fromchild[2] = {-1, -1};
if (argc < 2) _exit(111);
if (!argv[0]) _exit(111);
if (!argv[1]) _exit(111);
++argv;
if (pipe(tochild) == -1) _exit(111);
if (pipe(fromchild) == -1) _exit(111);
pid = fork();
if (pid == -1) _exit(111);
if (pid == 0) {
close(tochild[1]);
close(fromchild[0]);
close(1); /* simulate closed connection */
if (dup2(tochild[0], 0) == -1) _exit(111);
if (dup2(fromchild[1], 1) == -1) _exit(111);
execvp(*argv, argv);
_exit(111);
}
close(tochild[0]);
close(fromchild[1]);
close(0);
if (dup2(fromchild[0], 0) == -1) _exit(111);
close(1);
if (dup2(tochild[1], 1) == -1) _exit(111);
signal(SIGPIPE, SIG_IGN);
_exit(111);
}
tinyssh-20250126/_tinysshd-test-hello2.c 0000664 0000000 0000000 00000003570 14745512304 0020000 0 ustar 00root root 0000000 0000000 /*
20160225
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include "log.h"
#include "packet.h"
#include "global.h"
#include "str.h"
#include "writeall.h"
static void cleanup(void) { global_purge(); }
__attribute__((noreturn)) static void die_fatal(const char *trouble,
const char *d, const char *fn) {
cleanup();
if (d) {
if (fn)
log_f5(trouble, " ", d, "/", fn);
else
log_f3(trouble, " ", d);
}
else { log_f1(trouble); }
_exit(111);
}
int main(int argc, char **argv) {
pid_t pid;
int tochild[2] = {-1, -1};
int fromchild[2] = {-1, -1};
const char *message;
long long messagelen;
if (argc < 2) _exit(111);
if (!argv[0]) _exit(111);
if (!argv[1]) _exit(111);
if (!argv[2]) _exit(111);
++argv;
message = *argv;
messagelen = str_len(message);
++argv;
if (pipe(tochild) == -1) _exit(111);
if (pipe(fromchild) == -1) _exit(111);
pid = fork();
if (pid == -1) _exit(111);
if (pid == 0) {
close(tochild[1]);
close(fromchild[0]);
if (dup2(tochild[0], 0) == -1) _exit(111);
if (dup2(fromchild[1], 1) == -1) _exit(111);
execvp(*argv, argv);
_exit(111);
}
close(tochild[0]);
close(fromchild[1]);
close(0);
if (dup2(fromchild[0], 0) == -1) _exit(111);
close(1);
if (dup2(tochild[1], 1) == -1) _exit(111);
signal(SIGPIPE, SIG_IGN);
global_init();
if (!packet_hello_receive())
die_fatal("unable to receive hello-string", 0, 0);
if (messagelen) {
if (writeall(1, message, messagelen) == -1)
die_fatal("unable to write hello-string", 0, 0);
if (writeall(1, "\r\n", 2) == -1)
die_fatal("unable to write hello-string", 0, 0);
}
_exit(111);
}
tinyssh-20250126/_tinysshd-test-kex1.c 0000664 0000000 0000000 00000003252 14745512304 0017460 0 ustar 00root root 0000000 0000000 /*
20160226
20241215 - reformated using clang-format
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include "log.h"
#include "packet.h"
#include "ssh.h"
#include "bug.h"
#include "packetparser.h"
#include "global.h"
static void cleanup(void) { global_purge(); }
__attribute__((noreturn)) static void die_fatal(const char *trouble,
const char *d, const char *fn) {
cleanup();
if (d) {
if (fn)
log_f5(trouble, " ", d, "/", fn);
else
log_f3(trouble, " ", d);
}
else { log_f1(trouble); }
_exit(111);
}
int main(int argc, char **argv) {
pid_t pid;
int tochild[2] = {-1, -1};
int fromchild[2] = {-1, -1};
if (argc < 2) _exit(111);
if (!argv[0]) _exit(111);
if (!argv[1]) _exit(111);
++argv;
if (pipe(tochild) == -1) _exit(111);
if (pipe(fromchild) == -1) _exit(111);
pid = fork();
if (pid == -1) _exit(111);
if (pid == 0) {
close(tochild[1]);
close(fromchild[0]);
if (dup2(tochild[0], 0) == -1) _exit(111);
if (dup2(fromchild[1], 1) == -1) _exit(111);
execvp(*argv, argv);
_exit(111);
}
close(tochild[0]);
close(fromchild[1]);
close(0);
if (dup2(fromchild[0], 0) == -1) _exit(111);
close(1);
if (dup2(tochild[1], 1) == -1) _exit(111);
signal(SIGPIPE, SIG_IGN);
global_init();
log_init(2, "_tinysshd-test-kex1", 0, 0);
if (!packet_hello_receive())
die_fatal("unable to receive hello-string", 0, 0);
if (!packet_hello_send()) die_fatal("unable to send hello-string", 0, 0);
_exit(111);
}
tinyssh-20250126/_tinysshd-test-kex2.c 0000664 0000000 0000000 00000012400 14745512304 0017454 0 ustar 00root root 0000000 0000000 /*
20160226
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include "log.h"
#include "packet.h"
#include "ssh.h"
#include "bug.h"
#include "packetparser.h"
#include "global.h"
static void cleanup(void) {
global_purge();
}
__attribute__((noreturn))
static void die_fatal(const char *trouble, const char *d, const char *fn) {
cleanup();
if (d) {
if (fn) log_f5(trouble, " ", d, "/", fn);
else log_f3(trouble, " ", d);
}
else {
log_f1(trouble);
}
_exit(111);
}
static int packet_disconnect_(struct buf *b) {
buf_purge(b);
buf_putnum8(b, SSH_MSG_DISCONNECT); /* byte SSH_MSG_DISCONNECT */
buf_putnum32(b, 0); /* uint32 reason code */
buf_putstring(b, "bye"); /* string description in ISO-10646 UTF-8 encoding [RFC3629] */
buf_putstring(b, ""); /* string language tag [RFC3066] */
packet_put(b);
return packet_sendall();
}
#if 0
static int _packet_debug(struct buf *b) {
buf_purge(b);
buf_putnum8(b, SSH_MSG_DEBUG); /* SSH_MSG_DEBUG */
buf_putnum8(b, 1); /* always_display */
buf_putstring(b, "test message"); /* message in ISO-10646 UTF-8 encoding [RFC3629] */
buf_putstring(b, ""); /* language tag [RFC3066] */
packet_put(b);
return packet_sendall();
}
#endif
static int packet_kex_receive_(void) {
struct buf *b = &packet.kexrecv;
long long pos = 0;
crypto_uint8 ch;
crypto_uint32 len;
if (!packet_getall(b, SSH_MSG_KEXINIT)) return 0;
/* parse packet */
pos = packetparser_uint8(b->buf, b->len, pos, &ch); /* SSH_MSG_KEXINIT */
if (ch != SSH_MSG_KEXINIT) bug_proto();
pos = packetparser_skip(b->buf, b->len, pos, 16); /* cookie */
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* kex algorithms */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("kex algorithms: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* server host key algorithms */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("server host key algorithms: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* encryption algorithms client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("encryption algorithms client to server: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* encryption algorithms server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("encryption algorithms server to client: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* mac algorithms client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("mac algorithms client to server: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* mac algorithms server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
log_i2("mac algorithms server to client: ", (char *)b->buf + pos - len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* compress algorithms client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* compress algorithms server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* languages client to server */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* languages server to client */
pos = packetparser_skip(b->buf, b->len, pos, len);
pos = packetparser_uint8(b->buf, b->len, pos, &ch); /* kex first packet follows */
pos = packetparser_uint32(b->buf, b->len, pos, &len); /* reserved */
return 1;
}
static unsigned char bspace[1024];
static struct buf b;
int main(int argc, char **argv) {
pid_t pid;
int tochild[2] = { -1, -1 };
int fromchild[2] = { -1, -1 };
if (argc < 2) _exit(111);
if (!argv[0]) _exit(111);
if (!argv[1]) _exit(111);
++argv;
buf_init(&b, bspace, sizeof bspace);
if (pipe(tochild) == -1) _exit(111);
if (pipe(fromchild) == -1) _exit(111);
pid = fork();
if (pid == -1) _exit(111);
if (pid == 0) {
close(tochild[1]);
close(fromchild[0]);
if (dup2(tochild[0], 0) == -1) _exit(111);
if (dup2(fromchild[1], 1) == -1) _exit(111);
execvp(*argv, argv);
_exit(111);
}
close(tochild[0]);
close(fromchild[1]);
close(0); if (dup2(fromchild[0], 0) == -1) _exit(111);
close(1); if (dup2(tochild[1], 1) == -1) _exit(111);
signal(SIGPIPE, SIG_IGN);
global_init();
log_init(0, "_tinysshd-test-kex1", 0, 0);
if (!packet_hello_receive()) die_fatal("unable to receive hello-string", 0, 0);
if (!packet_hello_send()) die_fatal("unable to send hello-string", 0, 0);
if (!packet_kex_receive_()) die_fatal("unable to receive kex-message", 0, 0);
if (!packet_disconnect_(&b)) die_fatal("unable to send disconnect-message", 0, 0);
_exit(111);
}
tinyssh-20250126/_tinysshd-unauthenticated.c 0000664 0000000 0000000 00000005130 14745512304 0021015 0 ustar 00root root 0000000 0000000 /*
20141210
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include "log.h"
#include "packet.h"
#include "ssh.h"
#include "bug.h"
#include "packetparser.h"
#include "global.h"
static void cleanup(void) { global_purge(); }
__attribute__((noreturn)) static void die_fatal(const char *trouble,
const char *d, const char *fn) {
cleanup();
if (d) {
if (fn)
log_f5(trouble, " ", d, "/", fn);
else
log_f3(trouble, " ", d);
}
else { log_f1(trouble); }
_exit(111);
}
static int packet_debug_(struct buf *b) {
buf_purge(b);
buf_putnum8(b, SSH_MSG_DEBUG); /* SSH_MSG_DEBUG */
buf_putnum8(b, 1); /* always_display */
buf_putstring(
b, "test message"); /* message in ISO-10646 UTF-8 encoding [RFC3629] */
buf_putstring(b, ""); /* language tag [RFC3066] */
packet_put(b);
return packet_sendall();
}
static unsigned char bspace[1024];
static struct buf b;
int main(int argc, char **argv) {
pid_t pid;
int tochild[2] = {-1, -1};
int fromchild[2] = {-1, -1};
long long i;
if (argc < 2) _exit(111);
if (!argv[0]) _exit(111);
if (!argv[1]) _exit(111);
++argv;
buf_init(&b, bspace, sizeof bspace);
if (pipe(tochild) == -1) _exit(111);
if (pipe(fromchild) == -1) _exit(111);
pid = fork();
if (pid == -1) _exit(111);
if (pid == 0) {
close(tochild[1]);
close(fromchild[0]);
close(2);
if (dup2(tochild[0], 0) == -1) _exit(111);
if (dup2(fromchild[1], 1) == -1) _exit(111);
execvp(*argv, argv);
_exit(111);
}
close(tochild[0]);
close(fromchild[1]);
close(0);
if (dup2(fromchild[0], 0) == -1) _exit(111);
close(1);
if (dup2(tochild[1], 1) == -1) _exit(111);
signal(SIGPIPE, SIG_IGN);
global_init();
log_init(1, "_tinysshd-unauthenticated", 0, 0);
if (!packet_hello_receive())
die_fatal("unable to receive hello-string", 0, 0);
if (!packet_hello_send()) die_fatal("unable to send hello-string", 0, 0);
for (i = 1; i < 100 * PACKET_UNAUTHENTICATED_MESSAGES; ++i) {
if (!packet_debug_(&b)) {
if (i < PACKET_UNAUTHENTICATED_MESSAGES)
die_fatal(
"unable to send debug message - parent died too early", 0,
0);
_exit(0); /* limitation works */
}
if (i > PACKET_UNAUTHENTICATED_MESSAGES) usleep(1000); /* XXX */
}
die_fatal("limitation is not working !!!!!!!!!!", 0, 0);
}
tinyssh-20250126/blocking.c 0000664 0000000 0000000 00000000505 14745512304 0015417 0 ustar 00root root 0000000 0000000 /*
taken from nacl-20110221, from from curvecp/blocking.c
- reformated using clang-format
*/
#include
#include "blocking.h"
void blocking_enable(int fd) {
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
}
void blocking_disable(int fd) {
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK);
}
tinyssh-20250126/blocking.h 0000664 0000000 0000000 00000000174 14745512304 0015426 0 ustar 00root root 0000000 0000000 #ifndef BLOCKING_H____
#define BLOCKING_H____
extern void blocking_enable(int);
extern void blocking_disable(int);
#endif
tinyssh-20250126/buf.c 0000664 0000000 0000000 00000013716 14745512304 0014413 0 ustar 00root root 0000000 0000000 /*
20140108
20241208 - reformated using clang-format
Jan Mojzis
Public domain.
The 'buf' library holds a string in allocated space.
The string length is limited by allocated memory.
All 'buf_put*' functions checks the limit and if
the string exceeds the limit, 'buf_put*' function
immediately exits with 111 status code.
*/
#include "byte.h"
#include "str.h"
#include "purge.h"
#include "randombytes.h"
#include "crypto_uint32.h"
#include "bug.h"
#include "buf.h"
/*
Initialize 'b' structure.
*/
void buf_init_(const char *fn, unsigned long long line, struct buf *b,
unsigned char *buf, long long alloc) {
if (!b || !buf || alloc <= 0 || alloc > 1073741824) bug_inval_(fn, line);
b->buf = buf;
b->len = 0;
b->alloc = alloc;
purge(b->buf, b->alloc);
}
/*
Remove content of 'b'.
*/
void buf_purge_(const char *fn, unsigned long long line, struct buf *b) {
if (!b || b->len < 0 || b->len > 1073741824 || b->alloc <= 0 ||
b->alloc > 1073741824 || !b->buf)
bug_inval_(fn, line);
purge(b->buf, b->len);
b->len = 0;
}
/*
Retun if 'b' has available space for string of length 'len'.
*/
int buf_ready_(const char *fn, unsigned long long line, struct buf *b,
long long len) {
if (!b || b->len < 0 || b->len > 1073741824 || b->alloc <= 0 ||
b->alloc > 1073741824 || !b->buf || len < 0 || len > 1073741824)
bug_inval_(fn, line);
return (b->len + len < b->alloc);
}
/*
Put string 'x' of length 'len'.
*/
int buf_put_(const char *fn, unsigned long long line, struct buf *b,
const unsigned char *x, long long len) {
if (!b || b->len < 0 || b->len > 1073741824 || b->alloc <= 0 ||
b->alloc > 1073741824 || !b->buf || !x || len < 0 || len > 1073741824)
bug_inval_(fn, line);
if (b->len + len >= b->alloc) bug_nomem_(fn, line);
byte_copy(b->buf + b->len, len, x);
b->len += len;
return 1;
}
/*
Put 0-terminated string 'x'.
*/
int buf_puts_(const char *fn, unsigned long long line, struct buf *b,
const char *x) {
return buf_put_(fn, line, b, (const unsigned char *) x, str_len(x));
}
/*
Put zero bytes of length 'len'.
*/
int buf_putzerobytes_(const char *fn, unsigned long long line, struct buf *b,
long long len) {
if (!b || b->len < 0 || b->len > 1073741824 || b->alloc <= 0 ||
b->alloc > 1073741824 || !b->buf || len < 0 || len > 1073741824)
bug_inval_(fn, line);
if (b->len + len >= b->alloc) bug_nomem_(fn, line);
byte_zero(b->buf + b->len, len);
b->len += len;
return 1;
}
/*
Put random bytes of length 'len'.
*/
int buf_putrandombytes_(const char *fn, unsigned long long line, struct buf *b,
long long len) {
if (!b || b->len < 0 || b->len > 1073741824 || b->alloc <= 0 ||
b->alloc > 1073741824 || !b->buf || len < 0 || len > 1073741824)
bug_inval_(fn, line);
if (b->len + len >= b->alloc) bug_nomem_(fn, line);
randombytes(b->buf + b->len, len);
b->len += len;
return 1;
}
/*
Put padding of length 'len'.
*/
int buf_putpadding_(const char *fn, unsigned long long line, struct buf *b,
long long len) {
if (!b || b->len < 0 || b->len > 1073741824 || b->alloc <= 0 ||
b->alloc > 1073741824 || !b->buf || len < 0 || len > 1073741824)
bug_inval_(fn, line);
if (b->len + len >= b->alloc) bug_nomem_(fn, line);
purge(b->buf + b->len, len);
b->len += len;
return 1;
}
/*
Put 32-bit unsigned integer in big-endian format.
*/
int buf_putnum32_(const char *fn, unsigned long long line, struct buf *b,
crypto_uint32 x) {
unsigned char s[4];
crypto_uint32_store_bigendian(s, x);
return buf_put_(fn, line, b, s, sizeof s);
}
/*
Put 8-bit unsigned integer.
*/
int buf_putnum8_(const char *fn, unsigned long long line, struct buf *b,
crypto_uint8 u) {
return buf_put_(fn, line, b, &u, 1);
}
/*
Put string 'x' of length 'len' and format it as a SSH-string.
*/
int buf_putstringlen_(const char *fn, unsigned long long line, struct buf *b,
const unsigned char *x, long long len) {
if (!buf_putnum32_(fn, line, b, len)) return 0;
return buf_put_(fn, line, b, x, len);
}
/*
Put 0-terminated string 'x' and format it as a SSH-string.
*/
int buf_putstring_(const char *fn, unsigned long long line, struct buf *b,
const char *x) {
return buf_putstringlen_(fn, line, b, (const unsigned char *) x,
str_len(x));
}
/*
Put SSH shared secret (bignum formated into wire format)
*/
int buf_putsharedsecret_(const char *fn, unsigned long long line, struct buf *b,
const unsigned char *x, long long len) {
long long pos;
if (len < 0 || len > 1073741824 || !b || !x) bug_inval_(fn, line);
for (pos = 0; pos < len; ++pos)
if (x[pos]) break;
if (x[pos] & 0x80) {
buf_putnum32_(fn, line, b, len - pos + 1);
buf_putnum8_(fn, line, b, 0);
}
else { buf_putnum32_(fn, line, b, len - pos + 0); }
return buf_put_(fn, line, b, x + pos, len - pos);
}
/*
Put string 'x' of length 'len' and encode it into base64.
*/
static const unsigned char b64chars[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
int buf_putbase64_(const char *fn, unsigned long long line, struct buf *b,
const unsigned char *x, long long len) {
long long i;
unsigned long long bits = 0, v = 0;
unsigned char ch;
if (len < 0 || len > 1073741824 || !b || !x) bug_inval_(fn, line);
for (i = 0; i < len; ++i) {
v <<= 8;
v += x[i];
bits += 8;
while (bits > 6) {
ch = b64chars[((v >> (bits - 6)) & 63)];
buf_putnum8_(fn, line, b, ch);
bits -= 6;
}
}
if (bits) {
v <<= (6 - bits);
ch = b64chars[v & 63];
buf_putnum8_(fn, line, b, ch);
}
while (b->len & 3) { buf_putnum8_(fn, line, b, '='); }
return 1;
}
tinyssh-20250126/buf.h 0000664 0000000 0000000 00000006124 14745512304 0014413 0 ustar 00root root 0000000 0000000 /*
20140108
20241208 - reformated using clang-format
Jan Mojzis
Public domain.
*/
#ifndef BUF_H____
#define BUF_H____
#include "crypto_uint8.h"
#include "crypto_uint32.h"
struct buf {
unsigned char *buf;
long long len;
long long alloc;
};
extern void buf_init_(const char *, unsigned long long, struct buf *,
unsigned char *, long long);
extern void buf_purge_(const char *, unsigned long long, struct buf *);
extern int buf_ready_(const char *, unsigned long long, struct buf *,
long long);
extern int buf_put_(const char *, unsigned long long, struct buf *,
const unsigned char *, long long);
extern int buf_puts_(const char *, unsigned long long, struct buf *,
const char *);
extern int buf_putzerobytes_(const char *, unsigned long long, struct buf *,
long long);
extern int buf_putrandombytes_(const char *, unsigned long long, struct buf *,
long long);
extern int buf_putpadding_(const char *, unsigned long long, struct buf *,
long long);
extern int buf_putnum32_(const char *, unsigned long long, struct buf *,
crypto_uint32);
extern int buf_putnum8_(const char *, unsigned long long, struct buf *,
crypto_uint8);
extern int buf_putstringlen_(const char *, unsigned long long, struct buf *,
const unsigned char *, long long);
extern int buf_putstring_(const char *, unsigned long long, struct buf *,
const char *);
extern int buf_putsharedsecret_(const char *, unsigned long long, struct buf *,
const unsigned char *, long long);
extern int buf_putbase64_(const char *, unsigned long long, struct buf *,
const unsigned char *, long long);
#define buf_init(a, b, cc) buf_init_(__FILE__, __LINE__, (a), (b), (cc))
#define buf_purge(a) buf_purge_(__FILE__, __LINE__, (a))
#define buf_ready(a, b) buf_ready_(__FILE__, __LINE__, (a), (b))
#define buf_put(a, b, cc) buf_put_(__FILE__, __LINE__, (a), (b), (cc))
#define buf_puts(a, b) buf_puts_(__FILE__, __LINE__, (a), (b))
#define buf_putzerobytes(a, b) buf_putzerobytes_(__FILE__, __LINE__, (a), (b))
#define buf_putrandombytes(a, b) \
buf_putrandombytes_(__FILE__, __LINE__, (a), (b))
#define buf_putpadding(a, b) buf_putpadding_(__FILE__, __LINE__, (a), (b))
#define buf_putnum32(a, b) buf_putnum32_(__FILE__, __LINE__, (a), (b))
#define buf_putnum8(a, b) buf_putnum8_(__FILE__, __LINE__, (a), (b))
#define buf_putstringlen(a, b, cc) \
buf_putstringlen_(__FILE__, __LINE__, (a), (b), (cc))
#define buf_putstring(a, b) buf_putstring_(__FILE__, __LINE__, (a), (b))
#define buf_putsharedsecret(a, b, cc) \
buf_putsharedsecret_(__FILE__, __LINE__, (a), (b), (cc))
#define buf_putbase64(a, b, cc) \
buf_putbase64_(__FILE__, __LINE__, (a), (b), (cc))
#endif
tinyssh-20250126/bug.h 0000664 0000000 0000000 00000004753 14745512304 0014422 0 ustar 00root root 0000000 0000000 #ifndef BUG_H____
#define BUG_H____
#include
#include "global.h"
#include "e.h"
#include "log.h"
#define bug_(a, b) \
do { \
log_9_(-1, 0, a, b, 0, 0, 0, 0, 0, 0, 0, 0, 0); \
global_die(111); \
} while (0)
#define bug() bug_(__FILE__, __LINE__)
#define bug_nomem() \
do { \
errno = ENOMEM; \
bug(); \
} while (0)
#define bug_proto() \
do { \
errno = EPROTO; \
bug(); \
} while (0)
#define bug_inval() \
do { \
errno = EINVAL; \
bug(); \
} while (0)
#define bug_nomem_(a, b) \
do { \
errno = ENOMEM; \
bug_(a, b); \
} while (0)
#define bug_proto_(a, b) \
do { \
errno = EPROTO; \
bug_(a, b); \
} while (0)
#define bug_inval_(a, b) \
do { \
errno = EINVAL; \
bug_(a, b); \
} while (0)
#endif
tinyssh-20250126/byte.c 0000664 0000000 0000000 00000001306 14745512304 0014572 0 ustar 00root root 0000000 0000000 /*
20241205
*/
#include "crypto_int16.h"
#include "byte.h"
void byte_copy(void *yv, long long ylen, const void *xv) {
long long i;
const char *x = xv;
char *y = yv;
for (i = 0; i < ylen; ++i) y[i] = x[i];
}
int byte_isequal(const void *yv, long long ylen, const void *xv) {
long long i;
const unsigned char *y = yv;
const unsigned char *x = xv;
unsigned char diff = 0;
for (i = 0; i < ylen; ++i) diff |= x[i] ^ y[i];
return crypto_int16_zero_01(diff);
}
void byte_zero(void *yv, long long ylen) {
long long i;
volatile char *y = yv;
for (i = 0; i < ylen; ++i) y[i] = 0;
#ifdef __GNUC__
__asm__ __volatile__("" : : "r"(yv) : "memory");
#endif
}
tinyssh-20250126/byte.h 0000664 0000000 0000000 00000000321 14745512304 0014573 0 ustar 00root root 0000000 0000000 #ifndef BYTE_H____
#define BYTE_H____
extern void byte_zero(void *, long long);
extern void byte_copy(void *, long long, const void *);
extern int byte_isequal(const void *, long long, const void *);
#endif
tinyssh-20250126/channel.c 0000664 0000000 0000000 00000027616 14745512304 0015253 0 ustar 00root root 0000000 0000000 /*
20140124
20241209 - reformated using clang-format
Jan Mojzis
Public domain.
The 'channel' library is used to handle data from/to SSH channel (rfc4254).
*/
#include
#include
#include
#include
#include
#include
#include
extern char *ptsname(int);
#include "byte.h"
#include "bug.h"
#include "newenv.h"
#include "e.h"
#include "purge.h"
#include "connectioninfo.h"
#include "iptostr.h"
#include "porttostr.h"
#include "buf.h"
#include "str.h"
#include "logsys.h"
#include "loginshell.h"
#include "trymlock.h"
#include "limit.h"
#include "channel.h"
/*
1. channel not open: maxpacket == 0, pid == 0
2. channel open: maxpacket != 0, pid == 0
3. child executed: maxpacket != 0, pid > 0, fd[01] != -1
4. child eof: maxpacket != 0, pid > 0, fd[12] == -1
5. child died: maxpacket != 0, pid == -1
*/
struct channel channel = {0};
/*
The 'channel_open' function opens the channel.
It sets 'localwindow' and maxpacket, values obtained from
from SSH_MSG_CHANNEL_OPEN message.
Function also obtaines connection information and sets
environment variables PATH, SSH_CONNECTION and MAIL.
*/
int channel_open(const char *user, crypto_uint32 id, crypto_uint32 remotewindow,
crypto_uint32 maxpacket, crypto_uint32 *localwindow) {
struct buf b = {channel.buf0, 0, CHANNEL_BUFSIZE};
if (!localwindow) bug_inval();
if (!maxpacket) bug_inval();
if (!remotewindow) bug_inval();
if (channel.maxpacket != 0) return 0;
if (channel.pid != 0) return 0;
/* copy user-name */
if (!str_copyn(channel.user, sizeof channel.user, user)) bug_nomem();
/* set id, maxpacket, remotewindow, localwindow */
channel.id = id;
channel.maxpacket = maxpacket;
channel.remotewindow = remotewindow;
channel.localwindow = *localwindow = CHANNEL_BUFSIZE;
/* copy PATH */
if (!newenv_copyenv("PATH")) {
if (!newenv_env("PATH", "/bin:/usr/bin")) return 0;
}
/* create env. SSH_CONNECTION */
connectioninfo(channel.localip, channel.localport, channel.remoteip,
channel.remoteport);
buf_purge(&b);
buf_puts(&b, channel.remoteip);
buf_puts(&b, " ");
buf_puts(&b, channel.remoteport);
buf_puts(&b, " ");
buf_puts(&b, channel.localip);
buf_puts(&b, " ");
buf_puts(&b, channel.localport);
buf_putnum8(&b, 0);
if (!newenv_env("SSH_CONNECTION", (char *) b.buf)) return 0;
#ifdef _PATH_MAILDIR
/* create env. MAIL */
buf_purge(&b);
buf_puts(&b, _PATH_MAILDIR);
buf_puts(&b, "/");
buf_puts(&b, user);
buf_putnum8(&b, 0);
if (!newenv_env("MAIL", (char *) b.buf)) return 0;
#endif
purge(channel.buf0, sizeof channel.buf0);
return 1;
}
/*
The 'channel_openterminal' function opens terminal,
sets environment variable TERM and initial terminal windowsize.
*/
int channel_openterminal(const char *name, crypto_uint32 a, crypto_uint32 b,
crypto_uint32 x, crypto_uint32 y) {
if (channel.maxpacket == 0) bug_proto();
if (channel.pid != 0) bug_proto();
if (channel.flagterminal == 1) bug_proto();
if (!channel_openpty(&channel.master, &channel.slave)) return 0;
if (!newenv_env("TERM", name)) return 0;
channel.flagterminal = 1;
channel.a = a;
channel.b = b;
channel.x = x;
channel.y = y;
return 1;
}
/*
The 'channel_ptyresize' function sets new
terminal windowsize.
*/
void channel_ptyresize(crypto_uint32 a, crypto_uint32 b, crypto_uint32 x,
crypto_uint32 y) {
struct winsize w;
if (channel.maxpacket == 0) bug_proto();
if (channel.pid <= 0) bug_proto();
if (!a && !b && !x && !y) return;
w.ws_col = a;
w.ws_row = b;
w.ws_xpixel = x;
w.ws_ypixel = y;
ioctl(channel.fd0, TIOCSWINSZ, &w);
}
/*
The 'channel_env' adds new environment variable
sent from client.
*/
int channel_env(const char *x, const char *y) {
if (channel.maxpacket == 0) bug_proto();
if (channel.pid != 0) bug_proto();
if (!x || !y) bug_inval();
return newenv_lowenv(x, y);
}
/*
The 'channel_exec' function executes new process.
If terminal is requsted, than users shell is executed,
if exec is requested, than command 'cmd' is executed.
Process is executed under appropriate users UID.
*/
int channel_exec(const char *cmd) {
char *run[4];
char *shell;
char *name;
int fd[3];
char ln[NAME_MAX + 2];
if (channel.maxpacket == 0) bug_proto();
if (channel.pid != 0) bug_proto();
if (channel.flagterminal) {
channel.pid = channel_forkpty(fd, channel.master, channel.slave);
if (channel.pid > 0) {
name = ptsname(fd[0]);
if (!name) bug();
if (!str_copyn(channel.termname, sizeof channel.termname, name))
bug_nomem();
}
}
else { channel.pid = channel_fork(fd); }
if (channel.pid == -1) return 0;
if (channel.pid == 0) {
logsys_login(channel.user, channel.remoteip, 0, 0);
if (!channel_droppriv(channel.user, &shell)) _exit(111);
if (cmd) {
run[0] = shell;
run[1] = (char *) "-c";
run[2] = (char *) cmd;
run[3] = 0;
}
else {
if (!loginshell(ln, sizeof ln, shell)) bug();
run[0] = ln;
run[1] = 0;
}
signal(SIGPIPE, SIG_DFL);
newenv_exec(shell, run);
_exit(111);
}
channel.fd0 = fd[0];
channel.fd1 = fd[1];
channel.fd2 = fd[2];
channel.len0 = 0;
newenv_purge();
if (channel.flagterminal && channel.pid > 0) {
channel_ptyresize(channel.a, channel.b, channel.x, channel.y);
}
return 1;
}
/*
The 'channel_put' function adds data from
client to childs buffer.
*/
void channel_put(unsigned char *buf, long long len) {
if (channel.maxpacket == 0) bug_proto();
if (channel.pid <= 0) bug_proto();
if (channel.fd0 == -1) bug_proto();
if (!buf || len < 0) bug_inval();
if (channel.len0 + len > CHANNEL_BUFSIZE) bug_nomem();
byte_copy(channel.buf0 + channel.len0, len, buf);
channel.len0 += len;
channel.localwindow -= len;
}
/*
The 'channel_puteof' function adds information
that remote side closed standard output.
*/
void channel_puteof(void) {
if (channel.maxpacket == 0) bug_proto();
if (channel.pid == 0) bug_proto();
if (channel.fd0 == -1) bug_proto();
channel.remoteeof = 1;
if (channel.len0 == 0 && !channel.flagterminal) {
close(channel.fd0);
channel.fd0 = -1;
}
}
/*
The 'channel_putisready' function returns
if child is ready accept data.
*/
int channel_putisready(void) {
if (channel.maxpacket == 0) return 0;
if (channel.pid <= 0) return 0;
if (channel.fd0 == -1) return 0;
return (CHANNEL_BUFSIZE > channel.len0);
}
/*
The 'channel_read' function reads
data from childs standard output.
*/
long long channel_read(unsigned char *buf, long long len) {
long long r;
if (channel.maxpacket == 0) bug_proto();
if (channel.pid <= 0) bug_proto();
if (channel.fd1 == -1) bug_proto();
if (!buf || len < 0) bug_inval();
if (channel.remotewindow <= 0) return 0;
r = len;
if (r > 1048576) r = 1048576;
if (r > channel.remotewindow) r = channel.remotewindow;
r = read(channel.fd1, buf, r);
if (r == -1) {
if (errno == EINTR) return 0;
if (errno == EAGAIN) return 0;
if (errno == EWOULDBLOCK) return 0;
}
if (r <= 0) {
channel.fd1 = -1;
return 0;
}
channel.remotewindow -= r;
return r;
}
/*
The 'channel_extendedread' function reads
data from childs error output.
*/
long long channel_extendedread(unsigned char *buf, long long len) {
long long r;
if (channel.maxpacket == 0) bug_proto();
if (channel.pid <= 0) bug_proto();
if (channel.fd2 == -1) bug_proto();
if (!buf || len < 0) bug_inval();
if (channel.remotewindow <= 0) return 0;
r = len;
if (r > 1048576) r = 1048576;
if (r > channel.remotewindow) r = channel.remotewindow;
r = read(channel.fd2, buf, r);
if (r == -1) {
if (errno == EINTR) return 0;
if (errno == EAGAIN) return 0;
if (errno == EWOULDBLOCK) return 0;
}
if (r <= 0) {
channel.fd2 = -1;
return 0;
}
channel.remotewindow -= r;
return r;
}
/*
The 'channel_readisready' function returns
if we can read data from childs standard output.
*/
int channel_readisready(void) {
if (channel.maxpacket == 0 || channel.pid == 0) return 0;
if (channel.fd1 == -1) return 0;
return (channel.remotewindow > 0);
}
/*
The 'channel_extendedreadisready' function returns
if we can read data from childs error output.
*/
int channel_extendedreadisready(void) {
if (channel.maxpacket == 0 || channel.pid == 0) return 0;
if (channel.fd2 == -1) return 0;
return (channel.remotewindow > 0);
}
/*
The 'channel_write' function writes
data to childs standard input.
*/
int channel_write(void) {
long long w;
if (channel.maxpacket == 0) bug_proto();
if (channel.pid <= 0) bug_proto();
if (channel.fd0 == -1) bug_proto();
if (channel.len0 <= 0) return 1;
w = write(channel.fd0, channel.buf0, channel.len0);
if (w == -1) {
if (errno == EINTR) return 1;
if (errno == EAGAIN) return 1;
if (errno == EWOULDBLOCK) return 1;
}
if (w <= 0) {
channel.fd0 = -1;
return 0;
}
byte_copy(channel.buf0, channel.len0 - w, channel.buf0 + w);
purge(channel.buf0 + channel.len0 - w, w);
channel.len0 -= w;
if (channel.remoteeof && channel.len0 == 0 && !channel.flagterminal) {
close(channel.fd0);
channel.fd0 = -1;
}
return 1;
}
/*
The 'channel_writeisready' function returns
if we can write data to childs standard input.
*/
int channel_writeisready(void) {
if (channel.maxpacket == 0) return 0;
if (channel.pid <= 0) return 0;
if (channel.fd0 == -1) return 0;
return (channel.len0 > 0);
}
/*
The 'channel_iseof' function returns
if child closed standard and error output.
*/
int channel_iseof(void) {
if (channel.maxpacket == 0) return 0;
if (channel.pid == 0) return 0;
if (channel.pid == -1) return 1;
return (channel.fd1 == -1 && channel.fd2 == -1);
}
/*
The 'channel_waitnohang' function returns
if child exited or was killed.
*/
int channel_waitnohang(int *s, int *e) {
int r, status;
if (!s || !e) bug_inval();
if (channel.maxpacket == 0) bug_proto();
if (channel.pid <= 0) return 0;
do {
r = waitpid(channel.pid, &status, WNOHANG);
} while (r == -1 && errno == EINTR);
if (r <= 0) return 0;
if (channel.flagterminal) {
logsys_logout(channel.user, channel.remoteip, channel.termname,
channel.pid);
}
if (WIFEXITED(status)) {
*e = WEXITSTATUS(status);
*s = 0;
}
else if (WIFSIGNALED(status)) {
*e = 0;
*s = WTERMSIG(status);
}
else { *e = *s = -1; }
channel.pid = -1;
return 1;
}
/*
Remove sentitive data from allocated memory.
*/
void channel_purge(void) {
purge(&channel, sizeof channel);
trymunlock(&channel, sizeof channel);
}
/*
Initialize channel structure.
*/
void channel_init(void) {
trymlock(&channel, sizeof channel);
purge(&channel, sizeof channel);
channel.maxpacket = 0;
channel.remoteeof = 0;
channel.len0 = 0;
channel.pid = 0;
channel.flagterminal = 0;
channel.master = -1;
channel.slave = -1;
}
int channel_getfd0(void) { return channel.fd0; }
int channel_getfd1(void) { return channel.fd1; }
int channel_getfd2(void) { return channel.fd2; }
long long channel_getlen0(void) { return channel.len0; }
crypto_uint32 channel_getid(void) { return channel.id; }
crypto_uint32 channel_getlocalwindow(void) { return channel.localwindow; }
void channel_incrementremotewindow(crypto_uint32 x) {
channel.remotewindow += x;
}
void channel_incrementlocalwindow(crypto_uint32 x) { channel.localwindow += x; }
tinyssh-20250126/channel.h 0000664 0000000 0000000 00000005310 14745512304 0015243 0 ustar 00root root 0000000 0000000 #ifndef CHANNEL_H____
#define CHANNEL_H____
#include "crypto_uint32.h"
#include "iptostr.h"
#include "porttostr.h"
#include "limit.h"
#define CHANNEL_BUFSIZE 131072
struct channel {
/* channel */
crypto_uint32 maxpacket;
crypto_uint32 id;
crypto_uint32 localwindow;
crypto_uint32 remotewindow;
/* child */
unsigned char buf0[CHANNEL_BUFSIZE];
long long len0;
long long pid;
int fd0;
int fd1;
int fd2;
int status;
/* ip */
char localip[IPTOSTR_LEN];
char localport[PORTTOSTR_LEN];
char remoteip[IPTOSTR_LEN];
char remoteport[PORTTOSTR_LEN];
/* terminal */
char user[LOGIN_NAME_MAX + 1];
char termname[TTY_NAME_MAX + 1];
int flagterminal;
int master;
int slave;
int a;
int b;
int x;
int y;
/* channel */
int remoteeof;
};
extern struct channel channel;
/* channel_drop.c */
extern int channel_droppriv(char *, char **);
/* channel_fork.c */
extern long long channel_fork(int[3]);
/* channel_forkpty.c */
extern long long channel_forkpty(int[3], int, int);
extern int channel_openpty(int *, int *);
/* channel.c */
extern void channel_purge(void);
extern int channel_open(const char *, crypto_uint32, crypto_uint32,
crypto_uint32, crypto_uint32 *);
extern int channel_openterminal(const char *, crypto_uint32, crypto_uint32,
crypto_uint32, crypto_uint32);
extern void channel_ptyresize(crypto_uint32, crypto_uint32, crypto_uint32,
crypto_uint32);
extern int channel_env(const char *, const char *);
extern int channel_exec(const char *);
extern void channel_put(unsigned char *, long long);
extern void channel_puteof(void);
extern int channel_putisready(void);
extern long long channel_read(unsigned char *, long long);
extern long long channel_extendedread(unsigned char *, long long);
extern int channel_readisready(void);
extern int channel_extendedreadisready(void);
extern int channel_write(void);
extern int channel_writeisready(void);
extern int channel_iseof(void);
extern int channel_waitnohang(int *, int *);
extern void channel_purge(void);
extern void channel_init(void);
extern int channel_getfd0(void);
extern int channel_getfd1(void);
extern int channel_getfd2(void);
extern long long channel_getlen0(void);
extern crypto_uint32 channel_getid(void);
extern crypto_uint32 channel_getlocalwindow(void);
extern void channel_incrementremotewindow(crypto_uint32);
extern void channel_incrementlocalwindow(crypto_uint32);
/* channel subsystem.c */
#define CHANNEL_SUBSYSTEM_MAX 64
extern int channel_subsystem_add(const char *);
extern const char *channel_subsystem_get(const char *);
extern void channel_subsystem_log(void);
#endif
tinyssh-20250126/channel_drop.c 0000664 0000000 0000000 00000002000 14745512304 0016253 0 ustar 00root root 0000000 0000000 /*
20140129
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include "dropuidgid.h"
#include "newenv.h"
#include "channel.h"
int channel_droppriv(char *user, char **shell) {
struct passwd *pw;
char *name;
pw = getpwnam(user);
if (!pw) return 0;
if (isatty(0)) {
name = ttyname(0);
if (!name) return 0;
if (!newenv_env("SSH_TTY", name)) return 0;
/* setowner */
if (chown(name, pw->pw_uid, pw->pw_gid) == -1) return 0;
if (chmod(name, 0600) == -1) return 0;
}
/* drop privileges */
if (!dropuidgid(pw->pw_name, pw->pw_uid, pw->pw_gid)) return 0;
if (chdir(pw->pw_dir) == -1) return 0;
if (!newenv_env("HOME", pw->pw_dir)) return 0;
if (!newenv_env("USER", pw->pw_name)) return 0;
if (!newenv_env("LOGNAME", pw->pw_name)) return 0;
if (!newenv_env("LOGIN", pw->pw_name)) return 0;
if (!newenv_env("SHELL", pw->pw_shell)) return 0;
*shell = pw->pw_shell;
return 1;
}
tinyssh-20250126/channel_fork.c 0000664 0000000 0000000 00000002246 14745512304 0016264 0 ustar 00root root 0000000 0000000 /*
20140129
20241209 - reformated using clang-format
Jan Mojzis
Public domain.
*/
#include
#include "blocking.h"
#include "open.h"
#include "channel.h"
/*
The 'channel_fork' function is used to create a new process.
Function creates 3 pipes from/to child:
fd[0] is pipe to childs standard input
fd[1] is pipe from childs standard output
fd[2] is pipe from childs error output
Function returns also childs PID.
*/
long long channel_fork(int fd[3]) {
int pi[2], pa[3], ch[3];
long long i, pid;
for (i = 0; i < 3; ++i) pa[i] = ch[i] = fd[i] = -1;
for (i = 0; i < 3; ++i) {
if (open_pipe(pi) == -1) goto cleanup;
pa[i] = pi[i ? 0 : 1];
ch[i] = pi[i ? 1 : 0];
}
pid = fork();
if (pid == -1) goto cleanup;
if (pid == 0) {
for (i = 0; i < 3; ++i) {
close(pa[i]);
close(i);
blocking_enable(ch[i]);
if (dup(ch[i]) != i) _exit(111);
}
return 0;
}
for (i = 0; i < 3; ++i) {
close(ch[i]);
fd[i] = pa[i];
}
return pid;
cleanup:
for (i = 0; i < 3; ++i) {
close(pa[i]);
close(ch[i]);
}
return -1;
}
tinyssh-20250126/channel_forkpty.c 0000664 0000000 0000000 00000007753 14745512304 0017031 0 ustar 00root root 0000000 0000000 /*
20150212
20241209 - reformated using clang-format
Jan Mojzis
Public domain.
*/
#include
#if defined(sun) || defined(__hpux)
#include
#endif
#include
#include
#include
#include
#include
extern char *ptsname(int);
extern int grantpt(int);
extern int unlockpt(int);
#include "hasopenpty.h"
#ifdef HASOPENPTY
extern int openpty(int *, int *, char *, struct termios *, struct winsize *);
#endif
#include "haslogintty.h"
#ifdef HASLOGINTTY
extern int login_tty(int);
#endif
#include "e.h"
#include "coe.h"
#include "blocking.h"
#include "global.h"
#include "channel.h"
#ifndef HASLOGINTTY
static int login_tty_(int fd) {
char *name;
setsid();
#ifdef TIOCSCTTY
if (ioctl(fd, TIOCSCTTY, (char *) 0) == -1) return -1;
#endif
name = ttyname(fd);
if (!name) return -1;
#ifndef TIOCSCTTY
if (fd != 0) close(0);
if (fd != 1) close(1);
if (fd != 2) close(2);
close(open(name, O_RDWR));
#endif
if (dup2(fd, 0) == -1) return -1;
if (dup2(fd, 1) == -1) return -1;
if (dup2(fd, 2) == -1) return -1;
if (fd > 2) close(fd);
return 0;
}
#endif
#ifndef HASOPENPTY
static int openpty_(int *amaster, int *aslave) {
int master = -1, slave = -1;
char *slave_name;
static const char *fn[] = {"/dev/ptmx", "/dev/ptc", 0};
long long i;
for (i = 0; fn[i]; ++i) {
master = open(fn[i], O_RDWR | O_NOCTTY);
if (master != -1) break;
}
if (master == -1) return -1;
if (grantpt(master) == -1) {
close(master);
return -1;
}
if (unlockpt(master) == -1) {
close(master);
return -1;
}
slave_name = ptsname(master);
if (!slave_name) {
close(master);
return -1;
}
slave = open(slave_name, O_RDWR | O_NOCTTY);
if (slave == -1) {
close(master);
return -1;
}
#if defined(sun) || defined(__hpux)
ioctl(slave, I_PUSH, "ptem");
ioctl(slave, I_PUSH, "ldterm");
#endif
#if defined(sun)
ioctl(slave, I_PUSH, "ttcompat");
#endif
if (amaster) *amaster = master;
if (aslave) *aslave = slave;
return 0;
}
#endif
int channel_openpty(int *amaster, int *aslave) {
#ifdef HASOPENPTY
if (openpty(amaster, aslave, 0, 0, 0) == -1) return 0;
#else
if (openpty_(amaster, aslave) == -1) return 0;
#endif
if (!ttyname(*aslave)) {
close(*amaster);
close(*aslave);
return 0;
}
return 1;
}
/*
The 'channel_forkpty' function is used to create a new process
operating in a pseudoterminal. Function sets 3 integers in 'fd[3]':
fd[0] and fd[1] is pseudoterminal fd
fd[2] is always -1
*/
long long channel_forkpty(int fd[3], int master, int slave) {
long long pid, r;
char ch;
int pi[2];
if (!ttyname(slave)) return -1;
if (pipe(pi) == -1) return -1;
fd[0] = fd[1] = master;
fd[2] = -1;
pid = fork();
switch (pid) {
case -1:
close(pi[0]);
close(pi[1]);
close(slave);
close(master);
return -1;
case 0:
close(master);
close(pi[0]);
#ifdef HASLOGINTTY
if (login_tty(slave) == -1) global_die(111);
#else
if (login_tty_(slave) == -1) global_die(111);
#endif
/* Trigger a read event on the other side of the pipe. */
do { r = write(pi[1], "", 1); } while (r == -1 && errno == EINTR);
close(pi[1]);
return 0;
default:
close(pi[1]);
coe_enable(master);
blocking_disable(master);
/*
Wait until child calls login_tty(slave), so that we can safely
close(slave). Fixes race condition between close(slave) in parent
and login_tty(slave) in child process.
*/
do {
r = read(pi[0], &ch, sizeof ch);
} while (r == -1 && errno == EINTR);
close(pi[0]);
close(slave);
return pid;
}
}
tinyssh-20250126/channel_subsystem.c 0000664 0000000 0000000 00000002073 14745512304 0017357 0 ustar 00root root 0000000 0000000 /*
20150114
20241209 - reformated using clang-format
Jan Mojzis
Public domain.
*/
#include "str.h"
#include "log.h"
#include "e.h"
#include "channel.h"
static long long channel_subsystem_pos = 0;
static const char *channel_subsystem[CHANNEL_SUBSYSTEM_MAX] = {0};
int channel_subsystem_add(const char *x) {
if (channel_subsystem_pos >= CHANNEL_SUBSYSTEM_MAX) return 0;
channel_subsystem[channel_subsystem_pos++] = x;
return 1;
}
const char *channel_subsystem_get(const char *x) {
long long len, i;
if (!x) return 0;
len = str_len(x);
for (i = 0; i < CHANNEL_SUBSYSTEM_MAX; ++i) {
if (!channel_subsystem[i]) break;
if (str_start(channel_subsystem[i], x)) {
if (channel_subsystem[i][len] == '=') {
return channel_subsystem[i] + len + 1;
}
}
}
return 0;
}
void channel_subsystem_log(void) {
long long i;
for (i = 0; i < CHANNEL_SUBSYSTEM_MAX; ++i) {
if (!channel_subsystem[i]) break;
log_d3("subsystem: ", channel_subsystem[i], " registered");
}
}
tinyssh-20250126/cleanup.c 0000664 0000000 0000000 00000000372 14745512304 0015260 0 ustar 00root root 0000000 0000000 #include "cleanup.h"
void cleanup_(void *yv, long long ylen) {
volatile char *y = (volatile char *) yv;
while (ylen > 0) {
*y++ = 0;
--ylen;
}
#ifdef __GNUC__
__asm__ __volatile__("" : : "r"(yv) : "memory");
#endif
}
tinyssh-20250126/cleanup.h 0000664 0000000 0000000 00000000212 14745512304 0015256 0 ustar 00root root 0000000 0000000 #ifndef CLEANUP_H____
#define CLEANUP_H____
extern void cleanup_(void *, long long);
#define cleanup(x) cleanup_((x), sizeof(x))
#endif
tinyssh-20250126/coe.c 0000664 0000000 0000000 00000000533 14745512304 0014376 0 ustar 00root root 0000000 0000000 /*
20241112
*/
#include
#include "coe.h"
/*
The 'coe_enable(fd)' function enables
the close-on-exec flag on a file-descriptor 'fd'.
*/
void coe_enable(int fd) { fcntl(fd, F_SETFD, 1); }
/*
The 'coe_disable(fd)' function disables
the close-on-exec flag on a file-descriptor 'fd'.
*/
void coe_disable(int fd) { fcntl(fd, F_SETFD, 0); }
tinyssh-20250126/coe.h 0000664 0000000 0000000 00000000150 14745512304 0014376 0 ustar 00root root 0000000 0000000 #ifndef COE_H____
#define COE_H____
extern void coe_enable(int);
extern void coe_disable(int);
#endif
tinyssh-20250126/connectioninfo.c 0000664 0000000 0000000 00000007635 14745512304 0016655 0 ustar 00root root 0000000 0000000 /*
20140131
20241215 - reformated using clang-format
Jan Mojzis
Public domain.
*/
#include
#include
#include
#include
#include
#include "e.h"
#include "byte.h"
#include "iptostr.h"
#include "porttostr.h"
#include "env.h"
#include "str.h"
#include "connectioninfo.h"
/*
The connectioninfo_fromfd function gets
informations about TCP connection from
getsockname(), getpeername() libc functions.
*/
static int connectioninfo_fromfd(char *localip, char *localport, char *remoteip,
char *remoteport) {
long long i;
struct sockaddr_storage sa;
socklen_t salen;
int fd = 0;
unsigned char ip[16];
unsigned char port[2];
char *ipstr[2];
char *portstr[2];
int (*op[2])(int, struct sockaddr *, socklen_t *) = {getsockname,
getpeername};
ipstr[0] = localip;
portstr[0] = localport;
ipstr[1] = remoteip;
portstr[1] = remoteport;
for (i = 0; i < 2; ++i) {
salen = sizeof sa;
if (op[i](fd, (struct sockaddr *) &sa, &salen) == -1) return 0;
if (sa.ss_family == PF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *) &sa;
byte_copy(ip, 12, "\0\0\0\0\0\0\0\0\0\0\377\377");
byte_copy(ip + 12, 4, &sin->sin_addr);
byte_copy(port, 2, &sin->sin_port);
}
#ifdef PF_INET6
else if (sa.ss_family == PF_INET6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &sa;
byte_copy(ip, 16, &sin6->sin6_addr);
byte_copy(port, 2, &sin6->sin6_port);
}
#endif
else {
errno = EPROTONOSUPPORT;
return 0;
}
iptostr(ipstr[i], ip);
porttostr(portstr[i], port);
}
return 1;
}
static int env(char *y, long long ylen, const char *e) {
char *x;
x = env_get(e);
if (!x) return 0;
if (!str_copyn(y, ylen, x)) return 0;
return 1;
}
/*
The connectioninfo_fromtcpserverenv function gets
informations about TCP connection from environment.
*/
static int connectioninfo_fromtcpserverenv(char *localip, char *localport,
char *remoteip, char *remoteport) {
if (!env(localip, IPTOSTR_LEN, "TCPLOCALIP")) return 0;
if (!env(localport, PORTTOSTR_LEN, "TCPLOCALPORT")) return 0;
if (!env(remoteip, IPTOSTR_LEN, "TCPREMOTEIP")) return 0;
if (!env(remoteport, PORTTOSTR_LEN, "TCPREMOTEPORT")) return 0;
return 1;
}
/*
The connectioninfo_fromcurvecpserverenv function gets
informations about CurveCP connection from environment.
*/
static int connectioninfo_fromcurvecpserverenv(char *localip, char *localport,
char *remoteip,
char *remoteport) {
if (!env(localip, IPTOSTR_LEN, "CURVECPLOCALIP")) return 0;
if (!env(localport, PORTTOSTR_LEN, "CURVECPLOCALPORT")) return 0;
if (!env(remoteip, IPTOSTR_LEN, "CURVECPREMOTEIP")) return 0;
if (!env(remoteport, PORTTOSTR_LEN, "CURVECPREMOTEPORT")) return 0;
return 1;
}
#define unknown "unknown"
#define port0 "0"
/*
The connectioninfo function gets informations about TCP/CurveCP connection.
*/
void connectioninfo(char *localip, char *localport, char *remoteip,
char *remoteport) {
if (connectioninfo_fromtcpserverenv(localip, localport, remoteip,
remoteport))
return;
if (connectioninfo_fromcurvecpserverenv(localip, localport, remoteip,
remoteport))
return;
if (connectioninfo_fromfd(localip, localport, remoteip, remoteport)) return;
byte_copy(localip, sizeof unknown, unknown);
byte_copy(remoteip, sizeof unknown, unknown);
byte_copy(localport, sizeof port0, port0);
byte_copy(remoteport, sizeof port0, port0);
return;
}
tinyssh-20250126/connectioninfo.h 0000664 0000000 0000000 00000000177 14745512304 0016654 0 ustar 00root root 0000000 0000000 #ifndef CONNECTIONINFO_H____
#define CONNECTIONINFO_H____
extern void connectioninfo(char *, char *, char *, char *);
#endif
tinyssh-20250126/crypto.h 0000664 0000000 0000000 00000001505 14745512304 0015155 0 ustar 00root root 0000000 0000000 /* allways include local versions */
#include "crypto_int16.h"
#include "crypto_int32.h"
#include "crypto_int64.h"
#include "crypto_int8.h"
#include "crypto_uint16.h"
#include "crypto_uint32.h"
#include "crypto_uint64.h"
#include "crypto_uint8.h"
#include "crypto_verify_16.h"
#include "crypto_verify_32.h"
/* include randombytes from librandombytes */
#include "haslibrandombytes.h"
#ifdef HASLIBRANDOMBYTES
#include
#else
#include "randombytes.h"
#endif
/* TODO */
#include "crypto_hash_sha256.h"
#include "crypto_hash_sha512.h"
#include "crypto_kem_sntrup761.h"
#include "crypto_kem_sntrup761x25519.h"
#include "crypto_onetimeauth_poly1305.h"
#include "crypto_scalarmult_curve25519.h"
#include "crypto_dh_x25519.h"
#include "crypto_sign_ed25519.h"
#include "crypto_sort_uint32.h"
#include "crypto_stream_chacha20.h"
tinyssh-20250126/crypto_declassify.h 0000664 0000000 0000000 00000000664 14745512304 0017370 0 ustar 00root root 0000000 0000000 #ifndef crypto_declassify_h
#define crypto_declassify_h
#include "hasvalgrind.h"
#ifdef HASVALGRIND
#include
#define crypto_declassify_uses_valgrind 1
static void crypto_declassify(void *xv, long long xlen) {
VALGRIND_MAKE_MEM_DEFINED(xv, xlen);
}
#else
#define crypto_declassify_uses_valgrind 0
static void crypto_declassify(void *xv, long long xlen) {
(void) xv;
(void) xlen;
}
#endif
#endif
tinyssh-20250126/crypto_dh_x25519.c 0000664 0000000 0000000 00000001556 14745512304 0016566 0 ustar 00root root 0000000 0000000 #include "crypto_dh_x25519.h"
#include "haslib25519.h"
#ifdef HASLIB25519
#include
int crypto_dh_x25519_lib25519(unsigned char *k, const unsigned char *pk,
const unsigned char *sk) {
lib25519_dh_x25519(k, pk, sk);
return 0;
}
int crypto_dh_x25519_lib25519_keypair(unsigned char *pk, unsigned char *sk) {
lib25519_dh_x25519_keypair(pk, sk);
return 0;
}
#else
#include "randombytes.h"
#include "crypto_scalarmult_curve25519.h"
int crypto_dh_x25519_tinyssh(unsigned char *k, const unsigned char *pk,
const unsigned char *sk) {
return crypto_scalarmult_curve25519(k, sk, pk);
}
static const unsigned char basepoint[32] = {9};
int crypto_dh_x25519_tinyssh_keypair(unsigned char *q, unsigned char *n) {
randombytes(n, 32);
return crypto_dh_x25519(q, basepoint, n);
}
#endif
tinyssh-20250126/crypto_dh_x25519.h 0000664 0000000 0000000 00000003551 14745512304 0016570 0 ustar 00root root 0000000 0000000 #ifndef crypto_dh_x25519_H
#define crypto_dh_x25519_H
#include "haslib25519.h"
#ifdef HASLIB25519
#include
#define crypto_dh_x25519_lib25519_BYTES lib25519_dh_x25519_BYTES
#define crypto_dh_x25519_lib25519_PUBLICKEYBYTES \
lib25519_dh_x25519_PUBLICKEYBYTES
#define crypto_dh_x25519_lib25519_SECRETKEYBYTES \
lib25519_dh_x25519_SECRETKEYBYTES
extern int crypto_dh_x25519_lib25519(unsigned char *, const unsigned char *,
const unsigned char *);
extern int crypto_dh_x25519_lib25519_keypair(unsigned char *, unsigned char *);
#define crypto_dh_x25519 crypto_dh_x25519_lib25519
#define crypto_dh_x25519_keypair crypto_dh_x25519_lib25519_keypair
#define crypto_dh_x25519_BYTES crypto_dh_x25519_lib25519_BYTES
#define crypto_dh_x25519_PUBLICKEYBYTES crypto_dh_x25519_lib25519_PUBLICKEYBYTES
#define crypto_dh_x25519_SECRETKEYBYTES crypto_dh_x25519_lib25519_SECRETKEYBYTES
#define crypto_dh_x25519_IMPLEMENTATION "lib25519"
#define crypto_dh_x25519_VERSION lib25519_version
#else
#define crypto_dh_x25519_tinyssh_BYTES 32
#define crypto_dh_x25519_tinyssh_PUBLICKEYBYTES 32
#define crypto_dh_x25519_tinyssh_SECRETKEYBYTES 32
extern int crypto_dh_x25519_tinyssh(unsigned char *, const unsigned char *,
const unsigned char *);
extern int crypto_dh_x25519_tinyssh_keypair(unsigned char *, unsigned char *);
#define crypto_dh_x25519 crypto_dh_x25519_tinyssh
#define crypto_dh_x25519_keypair crypto_dh_x25519_tinyssh_keypair
#define crypto_dh_x25519_BYTES crypto_dh_x25519_tinyssh_BYTES
#define crypto_dh_x25519_PUBLICKEYBYTES crypto_dh_x25519_tinyssh_PUBLICKEYBYTES
#define crypto_dh_x25519_SECRETKEYBYTES crypto_dh_x25519_tinyssh_SECRETKEYBYTES
#define crypto_dh_x25519_IMPLEMENTATION "tinyssh"
#define crypto_dh_x25519_VERSION "-"
#endif
#endif
tinyssh-20250126/crypto_hash_sha256.c 0000664 0000000 0000000 00000005622 14745512304 0017247 0 ustar 00root root 0000000 0000000 /*
20241208
*/
#include "crypto_uint32.h"
#include "crypto_uint64.h"
#include "crypto_hash_sha256.h"
#define R(x, c) (((x) >> (c)) | ((x) << (32 - (c))))
#define Ch(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
#define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define Sigma0(x) (R((x), 2) ^ R((x), 13) ^ R((x), 22))
#define Sigma1(x) (R((x), 6) ^ R((x), 11) ^ R((x), 25))
#define sigma0(x) (R((x), 7) ^ R((x), 18) ^ ((x) >> 3))
#define sigma1(x) (R((x), 17) ^ R((x), 19) ^ ((x) >> 10))
static const crypto_uint32 K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
static void blocks(crypto_uint32 *z, const unsigned char *m,
unsigned long long n) {
crypto_uint32 b[8], a[8], w[64], t;
long long i, j;
for (i = 0; i < 8; ++i) a[i] = z[i];
while (n >= 64) {
for (i = 0; i < 16; ++i) w[i] = crypto_uint32_load_bigendian(m + 4 * i);
for (i = 16; i < 64; ++i)
w[i] =
(sigma1(w[i - 2]) + w[i - 7] + sigma0(w[i - 15]) + w[i - 16]);
for (i = 0; i < 64; ++i) {
for (j = 0; j < 8; ++j) b[j] = a[j];
t = a[7] + Sigma1(a[4]) + Ch(a[4], a[5], a[6]) + K[i] + w[i];
b[7] = t + Sigma0(a[0]) + Maj(a[0], a[1], a[2]);
b[3] += t;
for (j = 0; j < 8; ++j) a[(j + 1) % 8] = b[j];
}
for (i = 0; i < 8; ++i) {
a[i] += z[i];
z[i] = a[i];
}
m += 64;
n -= 64;
}
}
int crypto_hash_sha256_tinyssh(unsigned char *o, const unsigned char *m,
unsigned long long n) {
unsigned long long i;
unsigned char x[128];
unsigned long long b = n;
crypto_uint32 h[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
blocks(h, m, n);
m += n;
n &= 63;
m -= n;
for (i = 0; i < sizeof x; ++i) x[i] = 0;
for (i = 0; i < n; ++i) x[i] = m[i];
x[n] = 128;
n = 128 - 64 * (n < 56);
crypto_uint64_store_bigendian(x + n - 8, b << 3);
blocks(h, x, n);
for (i = 0; i < 8; ++i) crypto_uint32_store_bigendian(o + 4 * i, h[i]);
return 0;
}
tinyssh-20250126/crypto_hash_sha256.h 0000664 0000000 0000000 00000000714 14745512304 0017251 0 ustar 00root root 0000000 0000000 #ifndef crypto_hash_sha256_H
#define crypto_hash_sha256_H
#define crypto_hash_sha256_tinyssh_BYTES 32
extern int crypto_hash_sha256_tinyssh(unsigned char *, const unsigned char *,
unsigned long long);
#define crypto_hash_sha256 crypto_hash_sha256_tinyssh
#define crypto_hash_sha256_BYTES crypto_hash_sha256_tinyssh_BYTES
#define crypto_hash_sha256_IMPLEMENTATION "tinyssh"
#define crypto_hash_sha256_VERSION "-"
#endif
tinyssh-20250126/crypto_hash_sha512.h 0000664 0000000 0000000 00000001724 14745512304 0017246 0 ustar 00root root 0000000 0000000 #ifndef crypto_hash_sha512_H
#define crypto_hash_sha512_H
#include "haslib25519.h"
#ifndef HASLIB25519
#define crypto_hash_sha512_tinyssh_BYTES 64
extern int crypto_hash_sha512_tinyssh(unsigned char *, const unsigned char *,
unsigned long long);
#define crypto_hash_sha512 crypto_hash_sha512_tinyssh
#define crypto_hash_sha512_BYTES crypto_hash_sha512_tinyssh_BYTES
#define crypto_hash_sha512_IMPLEMENTATION "tinyssh"
#define crypto_hash_sha512_VERSION "-"
#else
#include
#define crypto_hash_sha512_lib25519_BYTES lib25519_hash_sha512_BYTES
extern int crypto_hash_sha512_lib25519(unsigned char *, const unsigned char *,
unsigned long long);
#define crypto_hash_sha512 crypto_hash_sha512_lib25519
#define crypto_hash_sha512_BYTES crypto_hash_sha512_lib25519_BYTES
#define crypto_hash_sha512_IMPLEMENTATION "lib25519"
#define crypto_hash_sha512_VERSION lib25519_version
#endif
#endif
tinyssh-20250126/crypto_hash_sha512_lib25519.c 0000664 0000000 0000000 00000000441 14745512304 0020470 0 ustar 00root root 0000000 0000000 #include "haslib25519.h"
#ifdef HASLIB25519
#include
#include "crypto_hash_sha512.h"
int crypto_hash_sha512_lib25519(unsigned char *o, const unsigned char *m,
unsigned long long n) {
lib25519_hash_sha512(o, m, n);
return 0;
}
#endif
tinyssh-20250126/crypto_hash_sha512_tinyssh.c 0000664 0000000 0000000 00000010361 14745512304 0021017 0 ustar 00root root 0000000 0000000 /*
20241210
- based on tweetnacl 20140427 (http://tweetnacl.cr.yp.to/software.html)
*/
#include "crypto_hash_sha512.h"
#include "haslib25519.h"
#ifndef HASLIB25519
#include "crypto_uint64.h"
#define R(x, c) (((x) >> (c)) ^ ((x) << (64 - (c))))
#define Ch(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
#define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define Sigma0(x) (R((x), 28) ^ R((x), 34) ^ R((x), 39))
#define Sigma1(x) (R((x), 14) ^ R((x), 18) ^ R((x), 41))
#define sigma0(x) (R((x), 1) ^ R((x), 8) ^ ((x) >> 7))
#define sigma1(x) (R((x), 19) ^ R((x), 61) ^ ((x) >> 6))
static const crypto_uint64 K[80] = {
0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL,
0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL,
0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL,
0xc19bf174cf692694ULL, 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL,
0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL,
0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, 0x27b70a8546d22ffcULL,
0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL,
0x92722c851482353bULL, 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL,
0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL,
0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, 0x748f82ee5defb2fcULL,
0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL,
0xc67178f2e372532bULL, 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL,
0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL,
0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL};
static void blocks(crypto_uint64 *z, const unsigned char *m, crypto_uint64 n) {
crypto_uint64 b[8], a[8], w[80], t;
long long i, j;
for (i = 0; i < 8; ++i) a[i] = z[i];
while (n >= 128) {
for (i = 0; i < 16; ++i) w[i] = crypto_uint64_load_bigendian(m + 8 * i);
for (i = 16; i < 80; ++i)
w[i] =
(sigma1(w[i - 2]) + w[i - 7] + sigma0(w[i - 15]) + w[i - 16]);
for (i = 0; i < 80; ++i) {
for (j = 0; j < 8; ++j) b[j] = a[j];
t = a[7] + Sigma1(a[4]) + Ch(a[4], a[5], a[6]) + K[i] + w[i];
b[7] = t + Sigma0(a[0]) + Maj(a[0], a[1], a[2]);
b[3] += t;
for (j = 0; j < 8; ++j) a[(j + 1) % 8] = b[j];
}
for (i = 0; i < 8; ++i) {
a[i] += z[i];
z[i] = a[i];
}
m += 128;
n -= 128;
}
}
int crypto_hash_sha512_tinyssh(unsigned char *o, const unsigned char *m,
unsigned long long n) {
unsigned long long i;
unsigned char x[256];
crypto_uint64 b = n;
crypto_uint64 h[8] = {0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL};
blocks(h, m, n);
m += n;
n &= 127;
m -= n;
for (i = 0; i < sizeof x; ++i) x[i] = 0;
for (i = 0; i < n; ++i) x[i] = m[i];
x[n] = 128;
n = 256 - 128 * (n < 112);
x[n - 9] = b >> 61;
crypto_uint64_store_bigendian(x + n - 8, b << 3);
blocks(h, x, n);
for (i = 0; i < 8; ++i) crypto_uint64_store_bigendian(o + 8 * i, h[i]);
return 0;
}
#endif
tinyssh-20250126/crypto_kem_sntrup761.h 0000664 0000000 0000000 00000006447 14745512304 0017674 0 ustar 00root root 0000000 0000000 #ifndef crypto_kem_sntrup761_H
#define crypto_kem_sntrup761_H
#include "haslibntruprime.h"
#ifndef HASLIBNTRUPRIME
#define crypto_kem_sntrup761_tinyssh_SECRETKEYBYTES 1763
#define crypto_kem_sntrup761_tinyssh_PUBLICKEYBYTES 1158
#define crypto_kem_sntrup761_tinyssh_CIPHERTEXTBYTES 1039
#define crypto_kem_sntrup761_tinyssh_BYTES 32
extern int crypto_kem_sntrup761_tinyssh_keypair(unsigned char *,
unsigned char *);
extern int crypto_kem_sntrup761_tinyssh_enc(unsigned char *, unsigned char *,
const unsigned char *);
extern int crypto_kem_sntrup761_tinyssh_dec(unsigned char *,
const unsigned char *,
const unsigned char *);
#define crypto_kem_sntrup761_keypair crypto_kem_sntrup761_tinyssh_keypair
#define crypto_kem_sntrup761_enc crypto_kem_sntrup761_tinyssh_enc
#define crypto_kem_sntrup761_dec crypto_kem_sntrup761_tinyssh_dec
#define crypto_kem_sntrup761_SECRETKEYBYTES \
crypto_kem_sntrup761_tinyssh_SECRETKEYBYTES
#define crypto_kem_sntrup761_PUBLICKEYBYTES \
crypto_kem_sntrup761_tinyssh_PUBLICKEYBYTES
#define crypto_kem_sntrup761_CIPHERTEXTBYTES \
crypto_kem_sntrup761_tinyssh_CIPHERTEXTBYTES
#define crypto_kem_sntrup761_BYTES crypto_kem_sntrup761_tinyssh_BYTES
#define crypto_kem_sntrup761_IMPLEMENTATION "tinyssh"
#define crypto_kem_sntrup761_VERSION "-"
#else
#include
#define crypto_kem_sntrup761_libntruprime_SECRETKEYBYTES \
sntrup761_SECRETKEYBYTES
#define crypto_kem_sntrup761_libntruprime_PUBLICKEYBYTES \
sntrup761_PUBLICKEYBYTES
#define crypto_kem_sntrup761_libntruprime_CIPHERTEXTBYTES \
sntrup761_CIPHERTEXTBYTES
#define crypto_kem_sntrup761_libntruprime_BYTES sntrup761_BYTES
extern int crypto_kem_sntrup761_libntruprime_keypair(unsigned char *,
unsigned char *);
extern int crypto_kem_sntrup761_libntruprime_enc(unsigned char *,
unsigned char *,
const unsigned char *);
extern int crypto_kem_sntrup761_libntruprime_dec(unsigned char *,
const unsigned char *,
const unsigned char *);
#define crypto_kem_sntrup761_keypair crypto_kem_sntrup761_libntruprime_keypair
#define crypto_kem_sntrup761_enc crypto_kem_sntrup761_libntruprime_enc
#define crypto_kem_sntrup761_dec crypto_kem_sntrup761_libntruprime_dec
#define crypto_kem_sntrup761_SECRETKEYBYTES \
crypto_kem_sntrup761_libntruprime_SECRETKEYBYTES
#define crypto_kem_sntrup761_PUBLICKEYBYTES \
crypto_kem_sntrup761_libntruprime_PUBLICKEYBYTES
#define crypto_kem_sntrup761_CIPHERTEXTBYTES \
crypto_kem_sntrup761_libntruprime_CIPHERTEXTBYTES
#define crypto_kem_sntrup761_BYTES crypto_kem_sntrup761_libntruprime_BYTES
#define crypto_kem_sntrup761_IMPLEMENTATION "libntruprime"
#define crypto_kem_sntrup761_VERSION "-"
#endif
#endif
tinyssh-20250126/crypto_kem_sntrup761_libntruprime.c 0000664 0000000 0000000 00000001334 14745512304 0022451 0 ustar 00root root 0000000 0000000 #include "haslibntruprime.h"
#ifdef HASLIBNTRUPRIME
#include
#include "crypto_kem_sntrup761.h"
int crypto_kem_sntrup761_libntruprime_keypair(unsigned char *pk,
unsigned char *sk) {
sntrup761_keypair(pk, sk);
return 0;
}
int crypto_kem_sntrup761_libntruprime_enc(unsigned char *c, unsigned char *k,
const unsigned char *pk) {
sntrup761_enc(c, k, pk);
return 0;
}
int crypto_kem_sntrup761_libntruprime_dec(unsigned char *k,
const unsigned char *c,
const unsigned char *sk) {
sntrup761_dec(k, c, sk);
return 0;
}
#endif
tinyssh-20250126/crypto_kem_sntrup761_tinyssh.c 0000664 0000000 0000000 00000070233 14745512304 0021442 0 ustar 00root root 0000000 0000000 #include "crypto_kem_sntrup761.h"
#include "haslibntruprime.h"
#ifndef HASLIBNTRUPRIME
/*
Original code: supercop-20210125/crypto_kem/sntrup761/ref
Modifications (Jan Mojzis):
- source code merged into single file
- crypto_kem renamed to crypto_kem_sntrup761_tinyssh
- crypto_declassify added
*/
/* See https://ntruprime.cr.yp.to/software.html for detailed documentation. */
#include
#include "crypto_uint64.h"
#include "crypto_uint32.h"
#include "crypto_uint16.h"
#include "crypto_int32.h"
#include "crypto_int16.h"
#include "crypto_int8.h"
#include "randombytes.h"
#include "crypto_verify_32.h"
#include "crypto_sort_uint32.h"
#include "crypto_hash_sha512.h"
#include "crypto_declassify.h"
#define uint64 crypto_uint64
#define uint32 crypto_uint32
#define uint16 crypto_uint16
#define int32 crypto_int32
#define int16 crypto_int16
#define int8 crypto_int8
/* uint32.c */
/*
CPU division instruction typically takes time depending on x.
This software is designed to take time independent of x.
Time still varies depending on m; user must ensure that m is constant.
Time also varies on CPUs where multiplication is variable-time.
There could be more CPU issues.
There could also be compiler issues.
*/
static void uint32_divmod_uint14(uint32 *q, uint16 *r, uint32 x, uint16 m) {
uint32 v = 0x80000000;
uint32 qpart;
uint32 mask;
v /= m;
/* caller guarantees m > 0 */
/* caller guarantees m < 16384 */
/* vm <= 2^31 <= vm+m-1 */
/* xvm <= 2^31 x <= xvm+x(m-1) */
*q = 0;
qpart = (x * (uint64) v) >> 31;
/* 2^31 qpart <= xv <= 2^31 qpart + 2^31-1 */
/* 2^31 qpart m <= xvm <= 2^31 qpart m + (2^31-1)m */
/* 2^31 qpart m <= 2^31 x <= 2^31 qpart m + (2^31-1)m + x(m-1) */
/* 0 <= 2^31 newx <= (2^31-1)m + x(m-1) */
/* 0 <= newx <= (1-1/2^31)m + x(m-1)/2^31 */
/* 0 <= newx <= (1-1/2^31)(2^14-1) + (2^32-1)((2^14-1)-1)/2^31 */
x -= qpart * m;
*q += qpart;
/* x <= 49146 */
qpart = (x * (uint64) v) >> 31;
/* 0 <= newx <= (1-1/2^31)m + x(m-1)/2^31 */
/* 0 <= newx <= m + 49146(2^14-1)/2^31 */
/* 0 <= newx <= m + 0.4 */
/* 0 <= newx <= m */
x -= qpart * m;
*q += qpart;
/* x <= m */
x -= m;
*q += 1;
mask = -(x >> 31);
x += mask & (uint32) m;
*q += mask;
/* x < m */
*r = x;
}
uint32 uint32_div_uint14(uint32 x, uint16 m) {
uint32 q;
uint16 r;
uint32_divmod_uint14(&q, &r, x, m);
return q;
}
uint16 uint32_mod_uint14(uint32 x, uint16 m) {
uint32 q;
uint16 r;
uint32_divmod_uint14(&q, &r, x, m);
return r;
}
/* int32.c */
static void int32_divmod_uint14(int32 *q, uint16 *r, int32 x, uint16 m) {
uint32 uq, uq2;
uint16 ur, ur2;
uint32 mask;
uint32_divmod_uint14(&uq, &ur, 0x80000000 + (uint32) x, m);
uint32_divmod_uint14(&uq2, &ur2, 0x80000000, m);
ur -= ur2;
uq -= uq2;
mask = -(uint32) (ur >> 15);
ur += mask & m;
uq += mask;
*r = ur;
*q = uq;
}
int32 int32_div_uint14(int32 x, uint16 m) {
int32 q;
uint16 r;
int32_divmod_uint14(&q, &r, x, m);
return q;
}
uint16 int32_mod_uint14(int32 x, uint16 m) {
int32 q;
uint16 r;
int32_divmod_uint14(&q, &r, x, m);
return r;
}
/* paramsmenu.h */
/* pick one of these three: */
#define SIZE761
#undef SIZE653
#undef SIZE857
/* pick one of these two: */
#define SNTRUP /* Streamlined NTRU Prime */
#undef LPR /* NTRU LPRime */
/* params.h */
#ifndef params_H
#define params_H
/* menu of parameter choices: */
/* what the menu means: */
#if defined(SIZE761)
#define p 761
#define q 4591
#define Rounded_bytes 1007
#ifndef LPR
#define Rq_bytes 1158
#define w 286
#else
#define w 250
#define tau0 2156
#define tau1 114
#define tau2 2007
#define tau3 287
#endif
#elif defined(SIZE653)
#define p 653
#define q 4621
#define Rounded_bytes 865
#ifndef LPR
#define Rq_bytes 994
#define w 288
#else
#define w 252
#define tau0 2175
#define tau1 113
#define tau2 2031
#define tau3 290
#endif
#elif defined(SIZE857)
#define p 857
#define q 5167
#define Rounded_bytes 1152
#ifndef LPR
#define Rq_bytes 1322
#define w 322
#else
#define w 281
#define tau0 2433
#define tau1 101
#define tau2 2265
#define tau3 324
#endif
#else
#error "no parameter set defined"
#endif
#ifdef LPR
#define I 256
#endif
#endif
/* Decode.c */
static void Decode(uint16 *out, const unsigned char *S, const uint16 *M,
long long len) {
if (len == 1) {
if (M[0] == 1)
*out = 0;
else if (M[0] <= 256)
*out = uint32_mod_uint14(S[0], M[0]);
else
*out = uint32_mod_uint14(S[0] + (((uint16) S[1]) << 8), M[0]);
}
if (len > 1) {
uint16 R2[(len + 1) / 2];
uint16 M2[(len + 1) / 2];
uint16 bottomr[len / 2];
uint32 bottomt[len / 2];
long long i;
for (i = 0; i < len - 1; i += 2) {
uint32 m = M[i] * (uint32) M[i + 1];
if (m > 256 * 16383) {
bottomt[i / 2] = 256 * 256;
bottomr[i / 2] = S[0] + 256 * S[1];
S += 2;
M2[i / 2] = (((m + 255) >> 8) + 255) >> 8;
}
else if (m >= 16384) {
bottomt[i / 2] = 256;
bottomr[i / 2] = S[0];
S += 1;
M2[i / 2] = (m + 255) >> 8;
}
else {
bottomt[i / 2] = 1;
bottomr[i / 2] = 0;
M2[i / 2] = m;
}
}
if (i < len) M2[i / 2] = M[i];
Decode(R2, S, M2, (len + 1) / 2);
for (i = 0; i < len - 1; i += 2) {
uint32 r = bottomr[i / 2];
uint32 r1;
uint16 r0;
r += bottomt[i / 2] * R2[i / 2];
uint32_divmod_uint14(&r1, &r0, r, M[i]);
r1 = uint32_mod_uint14(
r1, M[i + 1]); /* only needed for invalid inputs */
*out++ = r0;
*out++ = r1;
}
if (i < len) *out++ = R2[i / 2];
}
}
/* Encode.c */
/* 0 <= R[i] < M[i] < 16384 */
static void Encode(unsigned char *out, const uint16 *R, const uint16 *M,
long long len) {
if (len == 1) {
uint16 r = R[0];
uint16 m = M[0];
while (m > 1) {
*out++ = r;
r >>= 8;
m = (m + 255) >> 8;
}
}
if (len > 1) {
uint16 R2[(len + 1) / 2];
uint16 M2[(len + 1) / 2];
long long i;
for (i = 0; i < len - 1; i += 2) {
uint32 m0 = M[i];
uint32 r = R[i] + R[i + 1] * m0;
uint32 m = M[i + 1] * m0;
while (m >= 16384) {
*out++ = r;
r >>= 8;
m = (m + 255) >> 8;
}
R2[i / 2] = r;
M2[i / 2] = m;
}
if (i < len) {
R2[i / 2] = R[i];
M2[i / 2] = M[i];
}
Encode(out, R2, M2, (len + 1) / 2);
}
}
/* kem.c */
#ifdef LPR
#endif
/* ----- masks */
#ifndef LPR
/* return -1 if x!=0; else return 0 */
static int int16_nonzero_mask(int16 x) {
uint16 u = x; /* 0, else 1...65535 */
uint32 v = u; /* 0, else 1...65535 */
v = -v; /* 0, else 2^32-65535...2^32-1 */
v >>= 31; /* 0, else 1 */
return -v; /* 0, else -1 */
}
#endif
/* return -1 if x<0; otherwise return 0 */
static int int16_negative_mask(int16 x) {
uint16 u = x;
u >>= 15;
return -(int) u;
/* alternative with gcc -fwrapv: */
/* x>>15 compiles to CPU's arithmetic right shift */
}
/* ----- arithmetic mod 3 */
typedef int8 small;
/* F3 is always represented as -1,0,1 */
/* so ZZ_fromF3 is a no-op */
/* x must not be close to top int16 */
static small F3_freeze(int16 x) { return int32_mod_uint14(x + 1, 3) - 1; }
/* ----- arithmetic mod q */
#define q12 ((q - 1) / 2)
typedef int16 Fq;
/* always represented as -q12...q12 */
/* so ZZ_fromFq is a no-op */
/* x must not be close to top int32 */
static Fq Fq_freeze(int32 x) { return int32_mod_uint14(x + q12, q) - q12; }
#ifndef LPR
static Fq Fq_recip(Fq a1) {
int i = 1;
Fq ai = a1;
while (i < q - 2) {
ai = Fq_freeze(a1 * (int32) ai);
i += 1;
}
return ai;
}
#endif
/* ----- Top and Right */
#ifdef LPR
#define tau 16
static int8 Top(Fq C) { return (tau1 * (int32) (C + tau0) + 16384) >> 15; }
static Fq Right(int8 T) { return Fq_freeze(tau3 * (int32) T - tau2); }
#endif
/* ----- small polynomials */
#ifndef LPR
/* 0 if Weightw_is(r), else -1 */
static int Weightw_mask(small *r) {
int weight = 0;
int i;
for (i = 0; i < p; ++i) weight += r[i] & 1;
return int16_nonzero_mask(weight - w);
}
/* R3_fromR(R_fromRq(r)) */
static void R3_fromRq(small *out, const Fq *r) {
int i;
for (i = 0; i < p; ++i) out[i] = F3_freeze(r[i]);
}
/* h = f*g in the ring R3 */
static void R3_mult(small *h, const small *f, const small *g) {
small fg[p + p - 1];
small result;
int i, j;
for (i = 0; i < p; ++i) {
result = 0;
for (j = 0; j <= i; ++j) result = F3_freeze(result + f[j] * g[i - j]);
fg[i] = result;
}
for (i = p; i < p + p - 1; ++i) {
result = 0;
for (j = i - p + 1; j < p; ++j)
result = F3_freeze(result + f[j] * g[i - j]);
fg[i] = result;
}
for (i = p + p - 2; i >= p; --i) {
fg[i - p] = F3_freeze(fg[i - p] + fg[i]);
fg[i - p + 1] = F3_freeze(fg[i - p + 1] + fg[i]);
}
for (i = 0; i < p; ++i) h[i] = fg[i];
}
/* returns 0 if recip succeeded; else -1 */
static int R3_recip(small *out, const small *in) {
small f[p + 1], g[p + 1], v[p + 1], r[p + 1];
int i, loop, delta;
int sign, swap, t;
for (i = 0; i < p + 1; ++i) v[i] = 0;
for (i = 0; i < p + 1; ++i) r[i] = 0;
r[0] = 1;
for (i = 0; i < p; ++i) f[i] = 0;
f[0] = 1;
f[p - 1] = f[p] = -1;
for (i = 0; i < p; ++i) g[p - 1 - i] = in[i];
g[p] = 0;
delta = 1;
for (loop = 0; loop < 2 * p - 1; ++loop) {
for (i = p; i > 0; --i) v[i] = v[i - 1];
v[0] = 0;
sign = -g[0] * f[0];
swap = int16_negative_mask(-delta) & int16_nonzero_mask(g[0]);
delta ^= swap & (delta ^ -delta);
delta += 1;
for (i = 0; i < p + 1; ++i) {
t = swap & (f[i] ^ g[i]);
f[i] ^= t;
g[i] ^= t;
t = swap & (v[i] ^ r[i]);
v[i] ^= t;
r[i] ^= t;
}
for (i = 0; i < p + 1; ++i) g[i] = F3_freeze(g[i] + sign * f[i]);
for (i = 0; i < p + 1; ++i) r[i] = F3_freeze(r[i] + sign * v[i]);
for (i = 0; i < p; ++i) g[i] = g[i + 1];
g[p] = 0;
}
sign = f[0];
for (i = 0; i < p; ++i) out[i] = sign * v[p - 1 - i];
return int16_nonzero_mask(delta);
}
#endif
/* ----- polynomials mod q */
/* h = f*g in the ring Rq */
static void Rq_mult_small(Fq *h, const Fq *f, const small *g) {
Fq fg[p + p - 1];
Fq result;
int i, j;
for (i = 0; i < p; ++i) {
result = 0;
for (j = 0; j <= i; ++j)
result = Fq_freeze(result + f[j] * (int32) g[i - j]);
fg[i] = result;
}
for (i = p; i < p + p - 1; ++i) {
result = 0;
for (j = i - p + 1; j < p; ++j)
result = Fq_freeze(result + f[j] * (int32) g[i - j]);
fg[i] = result;
}
for (i = p + p - 2; i >= p; --i) {
fg[i - p] = Fq_freeze(fg[i - p] + fg[i]);
fg[i - p + 1] = Fq_freeze(fg[i - p + 1] + fg[i]);
}
for (i = 0; i < p; ++i) h[i] = fg[i];
}
#ifndef LPR
/* h = 3f in Rq */
static void Rq_mult3(Fq *h, const Fq *f) {
int i;
for (i = 0; i < p; ++i) h[i] = Fq_freeze(3 * f[i]);
}
/* out = 1/(3*in) in Rq */
/* returns 0 if recip succeeded; else -1 */
static int Rq_recip3(Fq *out, const small *in) {
Fq f[p + 1], g[p + 1], v[p + 1], r[p + 1];
int i, loop, delta;
int swap, t;
int32 f0, g0;
Fq scale;
for (i = 0; i < p + 1; ++i) v[i] = 0;
for (i = 0; i < p + 1; ++i) r[i] = 0;
r[0] = Fq_recip(3);
for (i = 0; i < p; ++i) f[i] = 0;
f[0] = 1;
f[p - 1] = f[p] = -1;
for (i = 0; i < p; ++i) g[p - 1 - i] = in[i];
g[p] = 0;
delta = 1;
for (loop = 0; loop < 2 * p - 1; ++loop) {
for (i = p; i > 0; --i) v[i] = v[i - 1];
v[0] = 0;
swap = int16_negative_mask(-delta) & int16_nonzero_mask(g[0]);
delta ^= swap & (delta ^ -delta);
delta += 1;
for (i = 0; i < p + 1; ++i) {
t = swap & (f[i] ^ g[i]);
f[i] ^= t;
g[i] ^= t;
t = swap & (v[i] ^ r[i]);
v[i] ^= t;
r[i] ^= t;
}
f0 = f[0];
g0 = g[0];
for (i = 0; i < p + 1; ++i) g[i] = Fq_freeze(f0 * g[i] - g0 * f[i]);
for (i = 0; i < p + 1; ++i) r[i] = Fq_freeze(f0 * r[i] - g0 * v[i]);
for (i = 0; i < p; ++i) g[i] = g[i + 1];
g[p] = 0;
}
scale = Fq_recip(f[0]);
for (i = 0; i < p; ++i) out[i] = Fq_freeze(scale * (int32) v[p - 1 - i]);
return int16_nonzero_mask(delta);
}
#endif
/* ----- rounded polynomials mod q */
static void Round(Fq *out, const Fq *a) {
int i;
for (i = 0; i < p; ++i) out[i] = a[i] - F3_freeze(a[i]);
}
/* ----- sorting to generate short polynomial */
static void Short_fromlist(small *out, const uint32 *in) {
uint32 L[p];
int i;
for (i = 0; i < w; ++i) L[i] = in[i] & (uint32) -2;
for (i = w; i < p; ++i) L[i] = (in[i] & (uint32) -3) | 1;
crypto_sort_uint32(L, p);
for (i = 0; i < p; ++i) out[i] = (L[i] & 3) - 1;
}
/* ----- underlying hash function */
#define Hash_bytes 32
/* e.g., b = 0 means out = Hash0(in) */
static void Hash_prefix(unsigned char *out, int b, const unsigned char *in,
int inlen) {
unsigned char x[inlen + 1];
unsigned char h[64];
int i;
x[0] = b;
for (i = 0; i < inlen; ++i) x[i + 1] = in[i];
crypto_hash_sha512(h, x, inlen + 1);
for (i = 0; i < 32; ++i) out[i] = h[i];
}
/* ----- higher-level randomness */
static uint32 urandom32(void) {
unsigned char c[4];
uint32 out[4];
randombytes(c, 4);
out[0] = (uint32) c[0];
out[1] = ((uint32) c[1]) << 8;
out[2] = ((uint32) c[2]) << 16;
out[3] = ((uint32) c[3]) << 24;
return out[0] + out[1] + out[2] + out[3];
}
static void Short_random(small *out) {
uint32 L[p];
int i;
for (i = 0; i < p; ++i) L[i] = urandom32();
Short_fromlist(out, L);
}
#ifndef LPR
static void Small_random(small *out) {
int i;
for (i = 0; i < p; ++i)
out[i] = (((urandom32() & 0x3fffffff) * 3) >> 30) - 1;
}
#endif
/* ----- Streamlined NTRU Prime Core */
#ifndef LPR
/* h,(f,ginv) = KeyGen() */
static void KeyGen(Fq *h, small *f, small *ginv) {
small g[p];
Fq finv[p];
for (;;) {
int result;
Small_random(g);
result = R3_recip(ginv, g);
crypto_declassify(&result, sizeof result);
if (result == 0) break;
}
Short_random(f);
Rq_recip3(finv, f); /* always works */
Rq_mult_small(h, finv, g);
}
/* c = Encrypt(r,h) */
static void Encrypt(Fq *c, const small *r, const Fq *h) {
Fq hr[p];
Rq_mult_small(hr, h, r);
Round(c, hr);
}
/* r = Decrypt(c,(f,ginv)) */
static void Decrypt(small *r, const Fq *c, const small *f, const small *ginv) {
Fq cf[p];
Fq cf3[p];
small e[p];
small ev[p];
int mask;
int i;
Rq_mult_small(cf, c, f);
Rq_mult3(cf3, cf);
R3_fromRq(e, cf3);
R3_mult(ev, e, ginv);
mask = Weightw_mask(ev); /* 0 if weight w, else -1 */
for (i = 0; i < w; ++i) r[i] = ((ev[i] ^ 1) & ~mask) ^ 1;
for (i = w; i < p; ++i) r[i] = ev[i] & ~mask;
}
#endif
/* ----- NTRU LPRime Core */
#ifdef LPR
/* (G,A),a = KeyGen(G); leaves G unchanged */
static void KeyGen(Fq *A, small *a, const Fq *G) {
Fq aG[p];
Short_random(a);
Rq_mult_small(aG, G, a);
Round(A, aG);
}
/* B,T = Encrypt(r,(G,A),b) */
static void Encrypt(Fq *B, int8 *T, const int8 *r, const Fq *G, const Fq *A,
const small *b) {
Fq bG[p];
Fq bA[p];
int i;
Rq_mult_small(bG, G, b);
Round(B, bG);
Rq_mult_small(bA, A, b);
for (i = 0; i < I; ++i) T[i] = Top(Fq_freeze(bA[i] + r[i] * q12));
}
/* r = Decrypt((B,T),a) */
static void Decrypt(int8 *r, const Fq *B, const int8 *T, const small *a) {
Fq aB[p];
int i;
Rq_mult_small(aB, B, a);
for (i = 0; i < I; ++i)
r[i] = -int16_negative_mask(Fq_freeze(Right(T[i]) - aB[i] + 4 * w + 1));
}
#endif
/* ----- encoding I-bit inputs */
#ifdef LPR
#define Inputs_bytes (I / 8)
typedef int8 Inputs[I]; /* passed by reference */
static void Inputs_encode(unsigned char *s, const Inputs r) {
int i;
for (i = 0; i < Inputs_bytes; ++i) s[i] = 0;
for (i = 0; i < I; ++i) s[i >> 3] |= r[i] << (i & 7);
}
#endif
/* ----- Expand */
#ifdef LPR
static const unsigned char aes_nonce[16] = {0};
static void Expand(uint32 *L, const unsigned char *k) {
int i;
crypto_stream_aes256ctr((unsigned char *) L, 4 * p, aes_nonce, k);
for (i = 0; i < p; ++i) {
uint32 L0 = ((unsigned char *) L)[4 * i];
uint32 L1 = ((unsigned char *) L)[4 * i + 1];
uint32 L2 = ((unsigned char *) L)[4 * i + 2];
uint32 L3 = ((unsigned char *) L)[4 * i + 3];
L[i] = L0 + (L1 << 8) + (L2 << 16) + (L3 << 24);
}
}
#endif
/* ----- Seeds */
#ifdef LPR
#define Seeds_bytes 32
static void Seeds_random(unsigned char *s) { randombytes(s, Seeds_bytes); }
#endif
/* ----- Generator, HashShort */
#ifdef LPR
/* G = Generator(k) */
static void Generator(Fq *G, const unsigned char *k) {
uint32 L[p];
int i;
Expand(L, k);
for (i = 0; i < p; ++i) G[i] = uint32_mod_uint14(L[i], q) - q12;
}
/* out = HashShort(r) */
static void HashShort(small *out, const Inputs r) {
unsigned char s[Inputs_bytes];
unsigned char h[Hash_bytes];
uint32 L[p];
Inputs_encode(s, r);
Hash_prefix(h, 5, s, sizeof s);
Expand(L, h);
Short_fromlist(out, L);
}
#endif
/* ----- NTRU LPRime Expand */
#ifdef LPR
/* (S,A),a = XKeyGen() */
static void XKeyGen(unsigned char *S, Fq *A, small *a) {
Fq G[p];
Seeds_random(S);
Generator(G, S);
KeyGen(A, a, G);
}
/* B,T = XEncrypt(r,(S,A)) */
static void XEncrypt(Fq *B, int8 *T, const int8 *r, const unsigned char *S,
const Fq *A) {
Fq G[p];
small b[p];
Generator(G, S);
HashShort(b, r);
Encrypt(B, T, r, G, A, b);
}
#define XDecrypt Decrypt
#endif
/* ----- encoding small polynomials (including short polynomials) */
#define Small_bytes ((p + 3) / 4)
/* these are the only functions that rely on p mod 4 = 1 */
static void Small_encode(unsigned char *s, const small *f) {
small x;
int i;
for (i = 0; i < p / 4; ++i) {
x = *f++ + 1;
x += (*f++ + 1) << 2;
x += (*f++ + 1) << 4;
x += (*f++ + 1) << 6;
*s++ = x;
}
x = *f++ + 1;
*s++ = x;
}
static void Small_decode(small *f, const unsigned char *s) {
unsigned char x;
int i;
for (i = 0; i < p / 4; ++i) {
x = *s++;
*f++ = ((small) (x & 3)) - 1;
x >>= 2;
*f++ = ((small) (x & 3)) - 1;
x >>= 2;
*f++ = ((small) (x & 3)) - 1;
x >>= 2;
*f++ = ((small) (x & 3)) - 1;
}
x = *s++;
*f++ = ((small) (x & 3)) - 1;
}
/* ----- encoding general polynomials */
#ifndef LPR
static void Rq_encode(unsigned char *s, const Fq *r) {
uint16 R[p], M[p];
int i;
for (i = 0; i < p; ++i) R[i] = r[i] + q12;
for (i = 0; i < p; ++i) M[i] = q;
Encode(s, R, M, p);
}
static void Rq_decode(Fq *r, const unsigned char *s) {
uint16 R[p], M[p];
int i;
for (i = 0; i < p; ++i) M[i] = q;
Decode(R, s, M, p);
for (i = 0; i < p; ++i) r[i] = ((Fq) R[i]) - q12;
}
#endif
/* ----- encoding rounded polynomials */
static void Rounded_encode(unsigned char *s, const Fq *r) {
uint16 R[p], M[p];
int i;
for (i = 0; i < p; ++i) R[i] = ((r[i] + q12) * 10923) >> 15;
for (i = 0; i < p; ++i) M[i] = (q + 2) / 3;
Encode(s, R, M, p);
}
static void Rounded_decode(Fq *r, const unsigned char *s) {
uint16 R[p], M[p];
int i;
for (i = 0; i < p; ++i) M[i] = (q + 2) / 3;
Decode(R, s, M, p);
for (i = 0; i < p; ++i) r[i] = R[i] * 3 - q12;
}
/* ----- encoding top polynomials */
#ifdef LPR
#define Top_bytes (I / 2)
static void Top_encode(unsigned char *s, const int8 *T) {
int i;
for (i = 0; i < Top_bytes; ++i) s[i] = T[2 * i] + (T[2 * i + 1] << 4);
}
static void Top_decode(int8 *T, const unsigned char *s) {
int i;
for (i = 0; i < Top_bytes; ++i) {
T[2 * i] = s[i] & 15;
T[2 * i + 1] = s[i] >> 4;
}
}
#endif
/* ----- Streamlined NTRU Prime Core plus encoding */
#ifndef LPR
typedef small Inputs[p]; /* passed by reference */
#define Inputs_random Short_random
#define Inputs_encode Small_encode
#define Inputs_bytes Small_bytes
#define Ciphertexts_bytes Rounded_bytes
#define SecretKeys_bytes (2 * Small_bytes)
#define PublicKeys_bytes Rq_bytes
/* pk,sk = ZKeyGen() */
static void ZKeyGen(unsigned char *pk, unsigned char *sk) {
Fq h[p];
small f[p], v[p];
KeyGen(h, f, v);
Rq_encode(pk, h);
Small_encode(sk, f);
sk += Small_bytes;
Small_encode(sk, v);
}
/* C = ZEncrypt(r,pk) */
static void ZEncrypt(unsigned char *C, const Inputs r,
const unsigned char *pk) {
Fq h[p];
Fq c[p];
Rq_decode(h, pk);
Encrypt(c, r, h);
Rounded_encode(C, c);
}
/* r = ZDecrypt(C,sk) */
static void ZDecrypt(Inputs r, const unsigned char *C,
const unsigned char *sk) {
small f[p], v[p];
Fq c[p];
Small_decode(f, sk);
sk += Small_bytes;
Small_decode(v, sk);
Rounded_decode(c, C);
Decrypt(r, c, f, v);
}
#endif
/* ----- NTRU LPRime Expand plus encoding */
#ifdef LPR
#define Ciphertexts_bytes (Rounded_bytes + Top_bytes)
#define SecretKeys_bytes Small_bytes
#define PublicKeys_bytes (Seeds_bytes + Rounded_bytes)
static void Inputs_random(Inputs r) {
unsigned char s[Inputs_bytes];
int i;
randombytes(s, sizeof s);
for (i = 0; i < I; ++i) r[i] = 1 & (s[i >> 3] >> (i & 7));
}
/* pk,sk = ZKeyGen() */
static void ZKeyGen(unsigned char *pk, unsigned char *sk) {
Fq A[p];
small a[p];
XKeyGen(pk, A, a);
pk += Seeds_bytes;
Rounded_encode(pk, A);
Small_encode(sk, a);
}
/* c = ZEncrypt(r,pk) */
static void ZEncrypt(unsigned char *c, const Inputs r,
const unsigned char *pk) {
Fq A[p];
Fq B[p];
int8 T[I];
Rounded_decode(A, pk + Seeds_bytes);
XEncrypt(B, T, r, pk, A);
Rounded_encode(c, B);
c += Rounded_bytes;
Top_encode(c, T);
}
/* r = ZDecrypt(C,sk) */
static void ZDecrypt(Inputs r, const unsigned char *c,
const unsigned char *sk) {
small a[p];
Fq B[p];
int8 T[I];
Small_decode(a, sk);
Rounded_decode(B, c);
Top_decode(T, c + Rounded_bytes);
XDecrypt(r, B, T, a);
}
#endif
/* ----- confirmation hash */
#define Confirm_bytes 32
/* h = HashConfirm(r,pk,cache); cache is Hash4(pk) */
static void HashConfirm(unsigned char *h, const unsigned char *r,
const unsigned char *pk, const unsigned char *cache) {
(void) pk;
#ifndef LPR
unsigned char x[Hash_bytes * 2];
int i;
Hash_prefix(x, 3, r, Inputs_bytes);
for (i = 0; i < Hash_bytes; ++i) x[Hash_bytes + i] = cache[i];
#else
unsigned char x[Inputs_bytes + Hash_bytes];
int i;
for (i = 0; i < Inputs_bytes; ++i) x[i] = r[i];
for (i = 0; i < Hash_bytes; ++i) x[Inputs_bytes + i] = cache[i];
#endif
Hash_prefix(h, 2, x, sizeof x);
}
/* ----- session-key hash */
/* k = HashSession(b,y,z) */
static void HashSession(unsigned char *k, int b, const unsigned char *y,
const unsigned char *z) {
#ifndef LPR
unsigned char x[Hash_bytes + Ciphertexts_bytes + Confirm_bytes];
int i;
Hash_prefix(x, 3, y, Inputs_bytes);
for (i = 0; i < Ciphertexts_bytes + Confirm_bytes; ++i)
x[Hash_bytes + i] = z[i];
#else
unsigned char x[Inputs_bytes + Ciphertexts_bytes + Confirm_bytes];
int i;
for (i = 0; i < Inputs_bytes; ++i) x[i] = y[i];
for (i = 0; i < Ciphertexts_bytes + Confirm_bytes; ++i)
x[Inputs_bytes + i] = z[i];
#endif
Hash_prefix(k, b, x, sizeof x);
}
/* ----- Streamlined NTRU Prime and NTRU LPRime */
/* pk,sk = KEM_KeyGen() */
static void KEM_KeyGen(unsigned char *pk, unsigned char *sk) {
int i;
ZKeyGen(pk, sk);
sk += SecretKeys_bytes;
for (i = 0; i < PublicKeys_bytes; ++i) *sk++ = pk[i];
randombytes(sk, Inputs_bytes);
sk += Inputs_bytes;
Hash_prefix(sk, 4, pk, PublicKeys_bytes);
}
/* c,r_enc = Hide(r,pk,cache); cache is Hash4(pk) */
static void Hide(unsigned char *c, unsigned char *r_enc, const Inputs r,
const unsigned char *pk, const unsigned char *cache) {
Inputs_encode(r_enc, r);
ZEncrypt(c, r, pk);
c += Ciphertexts_bytes;
HashConfirm(c, r_enc, pk, cache);
}
/* c,k = Encap(pk) */
static void Encap(unsigned char *c, unsigned char *k, const unsigned char *pk) {
Inputs r;
unsigned char r_enc[Inputs_bytes];
unsigned char cache[Hash_bytes];
Hash_prefix(cache, 4, pk, PublicKeys_bytes);
Inputs_random(r);
Hide(c, r_enc, r, pk, cache);
HashSession(k, 1, r_enc, c);
}
/* 0 if matching ciphertext+confirm, else -1 */
static int Ciphertexts_diff_mask(const unsigned char *c,
const unsigned char *c2) {
uint16 differentbits = 0;
int len = Ciphertexts_bytes + Confirm_bytes;
while (len-- > 0) differentbits |= (*c++) ^ (*c2++);
return crypto_int16_nonzero_mask(differentbits);
}
/* k = Decap(c,sk) */
static void Decap(unsigned char *k, const unsigned char *c,
const unsigned char *sk) {
const unsigned char *pk = sk + SecretKeys_bytes;
const unsigned char *rho = pk + PublicKeys_bytes;
const unsigned char *cache = rho + Inputs_bytes;
Inputs r;
unsigned char r_enc[Inputs_bytes];
unsigned char cnew[Ciphertexts_bytes + Confirm_bytes];
int mask;
int i;
ZDecrypt(r, c, sk);
Hide(cnew, r_enc, r, pk, cache);
mask = Ciphertexts_diff_mask(c, cnew);
for (i = 0; i < Inputs_bytes; ++i) r_enc[i] ^= mask & (r_enc[i] ^ rho[i]);
HashSession(k, 1 + mask, r_enc, c);
}
/* ----- crypto_kem_sntrup761_tinyssh API */
int crypto_kem_sntrup761_tinyssh_keypair(unsigned char *pk, unsigned char *sk) {
KEM_KeyGen(pk, sk);
return 0;
}
int crypto_kem_sntrup761_tinyssh_enc(unsigned char *c, unsigned char *k,
const unsigned char *pk) {
Encap(c, k, pk);
return 0;
}
int crypto_kem_sntrup761_tinyssh_dec(unsigned char *k, const unsigned char *c,
const unsigned char *sk) {
Decap(k, c, sk);
return 0;
}
#if 0
Script used to merge into single the file:
#!/ bin / sh
rm crypto_kem_sntrup761.c || :
(
cd "$1"
echo '/*'
echo 'Original code: supercop-20210125/crypto_kem/sntrup761/ref'
echo 'Modifications (Jan Mojzis):'
echo '- source code merged into single file'
echo '- crypto_kem renamed to crypto_kem_sntrup761_tinyssh'
echo '*/'
echo
echo '/* See https://ntruprime.cr.yp.to/software.html for detailed documentation. */'
echo
echo '#include '
echo '#include "crypto_uint64.h"'
echo '#include "crypto_uint32.h"'
echo '#include "crypto_uint16.h"'
echo '#include "crypto_int32.h"'
echo '#include "crypto_int16.h"'
echo '#include "crypto_int8.h"'
echo '#include "randombytes.h"'
echo '#include "crypto_verify_32.h"'
echo '#include "crypto_sort_uint32.h"'
echo '#include "crypto_hash_sha512.h"'
echo '#include "crypto_kem_sntrup761.h"'
echo ''
echo '#define uint64 crypto_uint64'
echo '#define uint32 crypto_uint32'
echo '#define uint16 crypto_uint16'
echo '#define int32 crypto_int32'
echo '#define int16 crypto_int16'
echo '#define int8 crypto_int8'
echo
(
for f in uint32.c int32.c paramsmenu.h params.h Decode.c Encode.c; do
echo "/* ${f} */"
cat "${f}" | sed 's/^void /static void /' | sed 's/^int16 /static int16 /'
echo
done | grep -v '#include'
)
(
echo '/* kem.c */'
cat kem.c
echo
) | grep -v '#include' | sed 's/crypto_kem/crypto_kem_sntrup761_tinyssh/g'
echo
echo '#if 0'
echo 'Script used to merge into single the file:'
echo
cat $0
echo
echo '#endif'
) > crypto_kem_sntrup761.c.tmp
mv -f crypto_kem_sntrup761.c.tmp crypto_kem_sntrup761.c
#endif
#endif
tinyssh-20250126/crypto_kem_sntrup761x25519.c 0000664 0000000 0000000 00000004123 14745512304 0020452 0 ustar 00root root 0000000 0000000 /*
20210314
20241211 - reformated using clang-format
20241215 - scalarmult_curve25519 -> dh_x25519
Jan Mojzis
Public domain.
*/
#include "cleanup.h"
#include "crypto_hash_sha512.h"
#include "crypto_dh_x25519.h"
#include "crypto_kem_sntrup761.h"
#include "crypto_kem_sntrup761x25519.h"
int crypto_kem_sntrup761x25519_tinyssh_enc(unsigned char *c, unsigned char *k,
const unsigned char *pk) {
unsigned char onetimesk[crypto_dh_x25519_SECRETKEYBYTES];
unsigned char buf[crypto_kem_sntrup761_BYTES + crypto_dh_x25519_BYTES];
/* sntrup761 */
crypto_kem_sntrup761_enc(c, buf, pk);
pk += crypto_kem_sntrup761_PUBLICKEYBYTES;
c += crypto_kem_sntrup761_CIPHERTEXTBYTES;
/* x25519 */
crypto_dh_x25519_keypair(/*onetimepk*/ c, onetimesk);
crypto_dh_x25519(buf + crypto_kem_sntrup761_BYTES, pk, onetimesk);
/* hash together sntrup459176 KEM-key and x25519 shared secret */
crypto_hash_sha512(k, buf, sizeof buf);
/* cleanup */
cleanup(buf);
cleanup(onetimesk);
return 0;
}
int crypto_kem_sntrup761x25519_tinyssh_dec(unsigned char *k,
const unsigned char *c,
const unsigned char *sk) {
unsigned char buf[crypto_kem_sntrup761_BYTES + crypto_dh_x25519_BYTES];
/* sntrup761 */
crypto_kem_sntrup761_dec(buf, c, sk);
sk += crypto_kem_sntrup761_SECRETKEYBYTES;
c += crypto_kem_sntrup761_CIPHERTEXTBYTES;
/* x25519 */
crypto_dh_x25519(buf + crypto_kem_sntrup761_BYTES, c, sk);
/* hash together sntrup459176 KEM-key and x25519 shared secret */
crypto_hash_sha512(k, buf, sizeof buf);
/* cleanup */
cleanup(buf);
return 0;
}
int crypto_kem_sntrup761x25519_tinyssh_keypair(unsigned char *pk,
unsigned char *sk) {
/* sntrup761 */
crypto_kem_sntrup761_keypair(pk, sk);
/* x25519 */
crypto_dh_x25519_keypair(pk + crypto_kem_sntrup761_PUBLICKEYBYTES,
sk + crypto_kem_sntrup761_SECRETKEYBYTES);
return 0;
}
tinyssh-20250126/crypto_kem_sntrup761x25519.h 0000664 0000000 0000000 00000003426 14745512304 0020464 0 ustar 00root root 0000000 0000000 #ifndef crypto_kem_sntrup761x25519_H
#define crypto_kem_sntrup761x25519_H
#define crypto_kem_sntrup761x25519_tinyssh_SECRETKEYBYTES 1795
#define crypto_kem_sntrup761x25519_tinyssh_PUBLICKEYBYTES 1190
#define crypto_kem_sntrup761x25519_tinyssh_CIPHERTEXTBYTES 1071
#define crypto_kem_sntrup761x25519_tinyssh_BYTES 64
extern int crypto_kem_sntrup761x25519_tinyssh_keypair(unsigned char *,
unsigned char *);
extern int crypto_kem_sntrup761x25519_tinyssh_enc(unsigned char *,
unsigned char *,
const unsigned char *);
extern int crypto_kem_sntrup761x25519_tinyssh_dec(unsigned char *,
const unsigned char *,
const unsigned char *);
#define crypto_kem_sntrup761x25519_keypair \
crypto_kem_sntrup761x25519_tinyssh_keypair
#define crypto_kem_sntrup761x25519_enc crypto_kem_sntrup761x25519_tinyssh_enc
#define crypto_kem_sntrup761x25519_dec crypto_kem_sntrup761x25519_tinyssh_dec
#define crypto_kem_sntrup761x25519_SECRETKEYBYTES \
crypto_kem_sntrup761x25519_tinyssh_SECRETKEYBYTES
#define crypto_kem_sntrup761x25519_PUBLICKEYBYTES \
crypto_kem_sntrup761x25519_tinyssh_PUBLICKEYBYTES
#define crypto_kem_sntrup761x25519_CIPHERTEXTBYTES \
crypto_kem_sntrup761x25519_tinyssh_CIPHERTEXTBYTES
#define crypto_kem_sntrup761x25519_BYTES \
crypto_kem_sntrup761x25519_tinyssh_BYTES
#define crypto_kem_sntrup761x25519_IMPLEMENTATION "tinyssh"
#define crypto_kem_sntrup761x25519_VERSION "-"
#endif
tinyssh-20250126/crypto_onetimeauth_poly1305.c 0000664 0000000 0000000 00000013043 14745512304 0021126 0 ustar 00root root 0000000 0000000 /*
20250126
*/
/*
Based on poly1305-donna (https://github.com/floodyberry/poly1305-donna)
- modified for NaCl API
- switched to cryptoint
*/
#include "crypto_int16.h"
#include "crypto_uint32.h"
#include "crypto_uint64.h"
#include "crypto_onetimeauth_poly1305.h"
/* clang-format off */
int crypto_onetimeauth_poly1305_tinyssh(unsigned char *o,
const unsigned char *m,
unsigned long long n,
const unsigned char *k) {
crypto_uint32 h0, h1, h2, h3, h4;
crypto_uint32 r0, r1, r2, r3, r4;
crypto_uint32 s1, s2, s3, s4;
crypto_uint64 d0, d1, d2, d3, d4;
crypto_uint32 c, mask;
crypto_uint64 f;
crypto_uint64 i;
/* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
r0 = (crypto_uint32_load(k + 0) ) & 0x3ffffff;
r1 = (crypto_uint32_load(k + 3) >> 2) & 0x3ffff03;
r2 = (crypto_uint32_load(k + 6) >> 4) & 0x3ffc0ff;
r3 = (crypto_uint32_load(k + 9) >> 6) & 0x3f03fff;
r4 = (crypto_uint32_load(k + 12) >> 8) & 0x00fffff;
s1 = r1 * 5;
s2 = r2 * 5;
s3 = r3 * 5;
s4 = r4 * 5;
/* h = 0 */
h0 = h1 = h2 = h3 = h4 = 0;
while (n > 0) {
/* h += m[i] */
if (n >= 16) {
h0 += (crypto_uint32_load(m ) ) & 0x3ffffff;
h1 += (crypto_uint32_load(m + 3) >> 2) & 0x3ffffff;
h2 += (crypto_uint32_load(m + 6) >> 4) & 0x3ffffff;
h3 += (crypto_uint32_load(m + 9) >> 6) & 0x3ffffff;
h4 += (crypto_uint32_load(m + 12) >> 8) | 16777216;
m += 16;
n -= 16;
}
else {
unsigned char mm[16];
for (i = 0; i < 16; ++i) mm[i] = 0;
for (i = 0; i < n; ++i) mm[i] = m[i];
mm[i] = 1;
h0 += (crypto_uint32_load(mm ) ) & 0x3ffffff;
h1 += (crypto_uint32_load(mm + 3) >> 2) & 0x3ffffff;
h2 += (crypto_uint32_load(mm + 6) >> 4) & 0x3ffffff;
h3 += (crypto_uint32_load(mm + 9) >> 6) & 0x3ffffff;
h4 += (crypto_uint32_load(mm + 12) >> 8);
n = 0;
}
/* h *= r */
d0 = ((crypto_uint64)h0 * r0) + ((crypto_uint64)h1 * s4) + ((crypto_uint64)h2 * s3) + ((crypto_uint64)h3 * s2) + ((crypto_uint64)h4 * s1);
d1 = ((crypto_uint64)h0 * r1) + ((crypto_uint64)h1 * r0) + ((crypto_uint64)h2 * s4) + ((crypto_uint64)h3 * s3) + ((crypto_uint64)h4 * s2);
d2 = ((crypto_uint64)h0 * r2) + ((crypto_uint64)h1 * r1) + ((crypto_uint64)h2 * r0) + ((crypto_uint64)h3 * s4) + ((crypto_uint64)h4 * s3);
d3 = ((crypto_uint64)h0 * r3) + ((crypto_uint64)h1 * r2) + ((crypto_uint64)h2 * r1) + ((crypto_uint64)h3 * r0) + ((crypto_uint64)h4 * s4);
d4 = ((crypto_uint64)h0 * r4) + ((crypto_uint64)h1 * r3) + ((crypto_uint64)h2 * r2) + ((crypto_uint64)h3 * r1) + ((crypto_uint64)h4 * r0);
/* (partial) h %= p */
c = (crypto_uint32)(d0 >> 26); h0 = (crypto_uint32)d0 & 0x3ffffff;
d1 += c; c = (crypto_uint32)(d1 >> 26); h1 = (crypto_uint32)d1 & 0x3ffffff;
d2 += c; c = (crypto_uint32)(d2 >> 26); h2 = (crypto_uint32)d2 & 0x3ffffff;
d3 += c; c = (crypto_uint32)(d3 >> 26); h3 = (crypto_uint32)d3 & 0x3ffffff;
d4 += c; c = (crypto_uint32)(d4 >> 26); h4 = (crypto_uint32)d4 & 0x3ffffff;
h0 += c * 5; c = (h0 >> 26); h0 = h0 & 0x3ffffff;
h1 += c;
}
/* fully carry h */
c = h1 >> 26; h1 = h1 & 0x3ffffff;
h2 += c; c = h2 >> 26; h2 = h2 & 0x3ffffff;
h3 += c; c = h3 >> 26; h3 = h3 & 0x3ffffff;
h4 += c; c = h4 >> 26; h4 = h4 & 0x3ffffff;
h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff;
h1 += c;
/* compute h + -p */
r0 = h0 + 5; c = r0 >> 26; r0 &= 0x3ffffff;
r1 = h1 + c; c = r1 >> 26; r1 &= 0x3ffffff;
r2 = h2 + c; c = r2 >> 26; r2 &= 0x3ffffff;
r3 = h3 + c; c = r3 >> 26; r3 &= 0x3ffffff;
r4 = h4 + c - (1 << 26);
/* select h if h < p, or h + -p if h >= p */
mask = crypto_uint32_topbit_01(r4);
mask -= 1;
r0 ^= h0;
r1 ^= h1;
r2 ^= h2;
r3 ^= h3;
r4 ^= h4;
h0 ^= mask & r0;
h1 ^= mask & r1;
h2 ^= mask & r2;
h3 ^= mask & r3;
h4 ^= mask & r4;
/* h = h % (2^128) */
h0 = ((h0 ) | (h1 << 26)) & 0xffffffff;
h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff;
h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff;
/* mac = (h + pad) % (2^128) */
f = (crypto_uint64)h0 + crypto_uint32_load(k + 16) ; h0 = (crypto_uint32)f;
f = (crypto_uint64)h1 + crypto_uint32_load(k + 20) + (f >> 32); h1 = (crypto_uint32)f;
f = (crypto_uint64)h2 + crypto_uint32_load(k + 24) + (f >> 32); h2 = (crypto_uint32)f;
f = (crypto_uint64)h3 + crypto_uint32_load(k + 28) + (f >> 32); h3 = (crypto_uint32)f;
crypto_uint32_store(o + 0, h0);
crypto_uint32_store(o + 4, h1);
crypto_uint32_store(o + 8, h2);
crypto_uint32_store(o + 12, h3);
return 0;
}
int crypto_onetimeauth_poly1305_tinyssh_verify(const unsigned char *h,
const unsigned char *in,
unsigned long long l,
const unsigned char *k) {
unsigned char correct[16];
crypto_int16 d = 0;
long long i;
crypto_onetimeauth_poly1305(correct, in, l, k);
for (i = 0; i < 16; ++i) d |= correct[i] ^ h[i];
return crypto_int16_nonzero_mask(d);
}
/* clang-format on */
tinyssh-20250126/crypto_onetimeauth_poly1305.h 0000664 0000000 0000000 00000002473 14745512304 0021140 0 ustar 00root root 0000000 0000000 #ifndef crypto_onetimeauth_poly1305_H
#define crypto_onetimeauth_poly1305_H
#define crypto_onetimeauth_poly1305_tinyssh_BYTES 16
#define crypto_onetimeauth_poly1305_tinyssh_KEYBYTES 32
extern int crypto_onetimeauth_poly1305_tinyssh(unsigned char *,
const unsigned char *,
unsigned long long,
const unsigned char *);
extern int crypto_onetimeauth_poly1305_tinyssh_verify(const unsigned char *,
const unsigned char *,
unsigned long long,
const unsigned char *);
#define crypto_onetimeauth_poly1305 crypto_onetimeauth_poly1305_tinyssh
#define crypto_onetimeauth_poly1305_verify \
crypto_onetimeauth_poly1305_tinyssh_verify
#define crypto_onetimeauth_poly1305_BYTES \
crypto_onetimeauth_poly1305_tinyssh_BYTES
#define crypto_onetimeauth_poly1305_KEYBYTES \
crypto_onetimeauth_poly1305_tinyssh_KEYBYTES
#define crypto_onetimeauth_poly1305_IMPLEMENTATION "tinyssh"
#define crypto_onetimeauth_poly1305_VERSION "-"
#endif
tinyssh-20250126/crypto_scalarmult_curve25519.c 0000664 0000000 0000000 00000003704 14745512304 0021214 0 ustar 00root root 0000000 0000000 #include "cleanup.h"
#include "fe25519.h"
#include "crypto_uint8.h"
#include "crypto_scalarmult_curve25519.h"
int crypto_scalarmult_curve25519_tinyssh(unsigned char *q,
const unsigned char *n,
const unsigned char *p) {
unsigned char e[32];
fe x1, x2, z2, x3, z3, tmp0, tmp1;
long long i;
int pos;
crypto_uint32 swap, b;
for (i = 0; i < 32; ++i) e[i] = n[i];
e[0] &= 248;
e[31] &= 127;
e[31] |= 64;
fe25519_frombytes(x1, p);
fe_1(x2);
fe_0(z2);
fe_copy(x3, x1);
fe_1(z3);
swap = 0;
for (pos = 254; pos >= 0; --pos) {
b = crypto_uint8_bitmod_01(e[pos / 8], pos);
swap ^= b;
fe_cswap(x2, x3, swap);
fe_cswap(z2, z3, swap);
swap = b;
fe25519_sub(tmp0, x3, z3);
fe25519_sub(tmp1, x2, z2);
fe25519_add(x2, x2, z2);
fe25519_add(z2, x3, z3);
fe25519_mul(z3, tmp0, x2);
fe25519_mul(z2, z2, tmp1);
fe25519_sq(tmp0, tmp1);
fe25519_sq(tmp1, x2);
fe25519_add(x3, z3, z2);
fe25519_sub(z2, z3, z2);
fe25519_mul(x2, tmp1, tmp0);
fe25519_sub(tmp1, tmp1, tmp0);
fe25519_sq(z2, z2);
fe25519_mul121666(z3, tmp1);
fe25519_sq(x3, x3);
fe25519_add(tmp0, tmp0, z3);
fe25519_mul(z3, x1, z2);
fe25519_mul(z2, tmp1, tmp0);
}
fe_cswap(x2, x3, swap);
fe_cswap(z2, z3, swap);
fe25519_inv(z2, z2);
fe25519_mul(x2, x2, z2);
fe25519_tobytes(q, x2);
cleanup(e);
cleanup(tmp0);
cleanup(tmp1);
cleanup(x1);
cleanup(x2);
cleanup(x3);
cleanup(z2);
cleanup(z3);
return 0;
}
static const unsigned char basepoint[32] = {9};
int crypto_scalarmult_curve25519_tinyssh_base(unsigned char *q,
const unsigned char *n) {
return crypto_scalarmult_curve25519_tinyssh(q, n, basepoint);
}
tinyssh-20250126/crypto_scalarmult_curve25519.h 0000664 0000000 0000000 00000002153 14745512304 0021216 0 ustar 00root root 0000000 0000000 #ifndef crypto_scalarmult_curve25519_H
#define crypto_scalarmult_curve25519_H
#define crypto_scalarmult_curve25519_tinyssh_BYTES 32
#define crypto_scalarmult_curve25519_tinyssh_SCALARBYTES 32
extern int crypto_scalarmult_curve25519_tinyssh(unsigned char *,
const unsigned char *,
const unsigned char *);
extern int crypto_scalarmult_curve25519_tinyssh_base(unsigned char *,
const unsigned char *);
#define crypto_scalarmult_curve25519 crypto_scalarmult_curve25519_tinyssh
#define crypto_scalarmult_curve25519_base \
crypto_scalarmult_curve25519_tinyssh_base
#define crypto_scalarmult_curve25519_BYTES \
crypto_scalarmult_curve25519_tinyssh_BYTES
#define crypto_scalarmult_curve25519_SCALARBYTES \
crypto_scalarmult_curve25519_tinyssh_SCALARBYTES
#define crypto_scalarmult_curve25519_IMPLEMENTATION "tinyssh"
#define crypto_scalarmult_curve25519_VERSION "-"
#endif
tinyssh-20250126/crypto_sign_ed25519.h 0000664 0000000 0000000 00000006357 14745512304 0017265 0 ustar 00root root 0000000 0000000 #ifndef crypto_sign_ed25519_H
#define crypto_sign_ed25519_H
#include "haslib25519.h"
#ifndef HASLIB25519
#define crypto_sign_ed25519_tinyssh_SECRETKEYBYTES 64
#define crypto_sign_ed25519_tinyssh_PUBLICKEYBYTES 32
#define crypto_sign_ed25519_tinyssh_BYTES 64
extern int crypto_sign_ed25519_tinyssh(unsigned char *, unsigned long long *,
const unsigned char *,
unsigned long long,
const unsigned char *);
extern int crypto_sign_ed25519_tinyssh_open(unsigned char *,
unsigned long long *,
const unsigned char *,
unsigned long long,
const unsigned char *);
extern int crypto_sign_ed25519_tinyssh_keypair(unsigned char *,
unsigned char *);
#define crypto_sign_ed25519 crypto_sign_ed25519_tinyssh
#define crypto_sign_ed25519_open crypto_sign_ed25519_tinyssh_open
#define crypto_sign_ed25519_keypair crypto_sign_ed25519_tinyssh_keypair
#define crypto_sign_ed25519_BYTES crypto_sign_ed25519_tinyssh_BYTES
#define crypto_sign_ed25519_PUBLICKEYBYTES \
crypto_sign_ed25519_tinyssh_PUBLICKEYBYTES
#define crypto_sign_ed25519_SECRETKEYBYTES \
crypto_sign_ed25519_tinyssh_SECRETKEYBYTES
#define crypto_sign_ed25519_IMPLEMENTATION "tinyssh"
#define crypto_sign_ed25519_VERSION "-"
#else
#include
#define crypto_sign_ed25519_lib25519_SECRETKEYBYTES \
lib25519_sign_ed25519_SECRETKEYBYTES
#define crypto_sign_ed25519_lib25519_PUBLICKEYBYTES \
lib25519_sign_ed25519_PUBLICKEYBYTES
#define crypto_sign_ed25519_lib25519_BYTES lib25519_sign_ed25519_BYTES
extern int crypto_sign_ed25519_lib25519(unsigned char *, unsigned long long *,
const unsigned char *,
unsigned long long,
const unsigned char *);
extern int crypto_sign_ed25519_lib25519_open(unsigned char *,
unsigned long long *,
const unsigned char *,
unsigned long long,
const unsigned char *);
extern int crypto_sign_ed25519_lib25519_keypair(unsigned char *,
unsigned char *);
#define crypto_sign_ed25519 crypto_sign_ed25519_lib25519
#define crypto_sign_ed25519_open crypto_sign_ed25519_lib25519_open
#define crypto_sign_ed25519_keypair crypto_sign_ed25519_lib25519_keypair
#define crypto_sign_ed25519_BYTES crypto_sign_ed25519_lib25519_BYTES
#define crypto_sign_ed25519_PUBLICKEYBYTES \
crypto_sign_ed25519_lib25519_PUBLICKEYBYTES
#define crypto_sign_ed25519_SECRETKEYBYTES \
crypto_sign_ed25519_lib25519_SECRETKEYBYTES
#define crypto_sign_ed25519_IMPLEMENTATION "lib25519"
#define crypto_sign_ed25519_VERSION lib25519_version
#endif
#endif
tinyssh-20250126/crypto_sign_ed25519_lib25519.c 0000664 0000000 0000000 00000002061 14745512304 0020500 0 ustar 00root root 0000000 0000000 #include "haslib25519.h"
#ifdef HASLIB25519
#include
#include "crypto_sign_ed25519.h"
int crypto_sign_ed25519_lib25519(unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long n,
const unsigned char *skorig) {
long long llsmlen;
lib25519_sign_ed25519(sm, &llsmlen, m, n, skorig);
*smlen = (unsigned long long) llsmlen;
return 0;
}
int crypto_sign_ed25519_lib25519_open(unsigned char *m,
unsigned long long *mlen,
const unsigned char *sm,
unsigned long long n,
const unsigned char *pk) {
long long llmlen;
int ret;
ret = lib25519_sign_ed25519_open(m, &llmlen, sm, n, pk);
*mlen = (unsigned long long) llmlen;
return ret;
}
int crypto_sign_ed25519_lib25519_keypair(unsigned char *pk, unsigned char *sk) {
lib25519_sign_ed25519_keypair(pk, sk);
return 0;
}
#endif
tinyssh-20250126/crypto_sign_ed25519_tinyssh.c 0000664 0000000 0000000 00000007111 14745512304 0021026 0 ustar 00root root 0000000 0000000 #include "crypto_sign_ed25519.h"
#include "haslib25519.h"
#ifndef HASLIB25519
#include "randombytes.h"
#include "cleanup.h"
#include "crypto_hash_sha512.h"
#include "crypto_verify_32.h"
#include "ge25519.h"
#include "sc25519.h"
int crypto_sign_ed25519_tinyssh(unsigned char *sm, unsigned long long *smlen,
const unsigned char *m, unsigned long long n,
const unsigned char *skorig) {
long long i;
unsigned char nonce[64], hram[64], sk[96], pk[32];
ge25519 R;
/* copy public key*/
for (i = 31; i >= 0; --i) pk[i] = skorig[i + 32];
/* compute secret key from seed sk = H(skorig), H = sha512 */
crypto_hash_sha512(sk, skorig, 32);
sk[0] &= 248;
sk[31] &= 63;
sk[31] |= 64;
randombytes(sk + 64, 32);
crypto_hash_sha512(sk + 32, sk + 32, 64);
/* copy m to sm, copy secret key */
*smlen = n + 64;
for (i = n - 1; i >= 0; --i) sm[i + 64] = m[i];
for (i = 31; i >= 0; --i) sm[i + 32] = sk[i + 32];
/* get pseudorandom nonce = H(sk2, m) */
crypto_hash_sha512(nonce, sm + 32, n + 32);
sc25519_reduce(nonce);
/* copy pk to sm */
for (i = 31; i >= 0; --i) sm[i + 32] = pk[i];
/* compute R */
ge25519_scalarmult_base(R, nonce);
ge25519_tobytes(sm, R);
/* calculate hram = H(r, a, m) */
crypto_hash_sha512(hram, sm, n + 64);
sc25519_reduce(hram);
/* compute S */
sc25519_muladd(sm + 32, hram, sk, nonce);
/* cleanup */
cleanup(nonce);
cleanup(hram);
cleanup(sk);
cleanup(pk);
cleanup(R);
return 0;
}
int crypto_sign_ed25519_tinyssh_open(unsigned char *m, unsigned long long *mlen,
const unsigned char *sm,
unsigned long long n,
const unsigned char *pk) {
unsigned long long i;
long long j;
unsigned char pkcopy[32], rcopy[32], scopy[32], hram[64], rcheck[32];
ge25519 R, S, A;
int ret = -1;
/* check input */
if (n < 64) goto fail;
if (sm[63] & 224) goto fail;
/* unpack pk */
if (ge25519_frombytes_negate_vartime(A, pk) != 0) goto fail;
/* copy pk, r, s */
for (i = 0; i < 32; ++i) pkcopy[i] = pk[i];
for (i = 0; i < 32; ++i) rcopy[i] = sm[i];
for (i = 0; i < 32; ++i) scopy[i] = sm[i + 32];
/* copy sm to m and copy pk to m */
for (j = n - 1; j >= 0; --j) m[j] = sm[j];
for (i = 0; i < 32; ++i) m[i + 32] = pkcopy[i];
/* calculate hram = H(r, a, m) */
crypto_hash_sha512(hram, m, n);
sc25519_reduce(hram);
/* compute R */
ge25519_scalarmult(A, A, hram);
ge25519_scalarmult_base(S, scopy);
ge25519_add(R, S, A);
/* check R */
ge25519_tobytes(rcheck, R);
if (crypto_verify_32(rcheck, rcopy) != 0) goto fail;
/* copy message */
n -= 64;
*mlen = n;
for (i = 0; i < n; ++i) m[i] = m[i + 64];
for (i = 0; i < 64; ++i) m[i + n] = 0;
ret = 0;
goto cleanup;
fail:
for (i = 0; i < n; ++i) m[i] = 0;
cleanup:
cleanup(pkcopy);
cleanup(rcopy);
cleanup(scopy);
cleanup(hram);
cleanup(rcheck);
cleanup(R);
cleanup(S);
cleanup(A);
return ret;
}
int crypto_sign_ed25519_tinyssh_keypair(unsigned char *pk, unsigned char *sk) {
unsigned char h[64];
ge25519 A;
long long i;
randombytes(sk, 32);
crypto_hash_sha512(h, sk, 32);
h[0] &= 248;
h[31] &= 63;
h[31] |= 64;
ge25519_scalarmult_base(A, h);
ge25519_tobytes(pk, A);
for (i = 31; i >= 0; --i) sk[i + 32] = pk[i];
cleanup(h);
cleanup(A);
return 0;
}
#endif
tinyssh-20250126/crypto_sort_uint32.c 0000664 0000000 0000000 00000001464 14745512304 0017427 0 ustar 00root root 0000000 0000000 #include "crypto_uint32.h"
#include "crypto_sort_uint32.h"
static void minmax(crypto_uint32 *x, crypto_uint32 *y) {
crypto_uint32 xi = *x;
crypto_uint32 yi = *y;
crypto_uint32 xy = xi ^ yi;
crypto_uint32 c = yi - xi;
c ^= xy & (c ^ yi ^ 0x80000000);
c >>= 31;
c &= 1;
c = -c;
c &= xy;
*x = xi ^ c;
*y = yi ^ c;
}
void crypto_sort_uint32_tinyssh(void *xv, long long n) {
long long top, p, q, i;
crypto_uint32 *x = xv;
if (n < 2) return;
top = 1;
while (top < n - top) top += top;
for (p = top; p > 0; p >>= 1) {
for (i = 0; i < n - p; ++i)
if (!(i & p)) minmax(x + i, x + i + p);
for (q = top; q > p; q >>= 1)
for (i = 0; i < n - q; ++i)
if (!(i & p)) minmax(x + i + p, x + i + q);
}
}
tinyssh-20250126/crypto_sort_uint32.h 0000664 0000000 0000000 00000000575 14745512304 0017436 0 ustar 00root root 0000000 0000000 #ifndef crypto_sort_uint32_H
#define crypto_sort_uint32_H
#define crypto_sort_uint32_tinyssh_BYTES 4
extern void crypto_sort_uint32_tinyssh(void *, long long);
#define crypto_sort_uint32 crypto_sort_uint32_tinyssh
#define crypto_sort_uint32_BYTES crypto_sort_uint32_tinyssh_BYTES
#define crypto_sort_uint32_IMPLEMENTATION "tinyssh"
#define crypto_sort_uint32_VERSION "-"
#endif
tinyssh-20250126/crypto_stream_chacha20.c 0000664 0000000 0000000 00000016252 14745512304 0020161 0 ustar 00root root 0000000 0000000 /*
20241112
*/
#include
#include "crypto_stream_chacha20.h"
static inline uint32_t unpack32(const unsigned char *x) {
uint32_t u0 = ((uint32_t) x[0]);
uint32_t u1 = ((uint32_t) x[1]) << 8;
uint32_t u2 = ((uint32_t) x[2]) << 16;
uint32_t u3 = ((uint32_t) x[3]) << 24;
return u0 ^ u1 ^ u2 ^ u3;
}
static inline void pack32(unsigned char *x, uint32_t u) {
x[0] = (unsigned char) (u);
x[1] = (unsigned char) (u >> 8);
x[2] = (unsigned char) (u >> 16);
x[3] = (unsigned char) (u >> 24);
}
#define ROTATE(x, c) ((x) << (c)) ^ ((x) >> (32 - (c)))
#define QUARTERROUND(a, b, c, d) \
a += b; \
d = ROTATE(d ^ a, 16); \
c += d; \
b = ROTATE(b ^ c, 12); \
a += b; \
d = ROTATE(d ^ a, 8); \
c += d; \
b = ROTATE(b ^ c, 7);
#define TWOROUNDS() \
QUARTERROUND(x0, x4, x8, x12) \
QUARTERROUND(x1, x5, x9, x13) \
QUARTERROUND(x2, x6, x10, x14) \
QUARTERROUND(x3, x7, x11, x15) \
QUARTERROUND(x0, x5, x10, x15) \
QUARTERROUND(x1, x6, x11, x12) \
QUARTERROUND(x2, x7, x8, x13) \
QUARTERROUND(x3, x4, x9, x14)
#define XORBLOCK(o, i) \
x0 = s0; \
x1 = s1; \
x2 = s2; \
x3 = s3; \
x4 = k0; \
x5 = k1; \
x6 = k2; \
x7 = k3; \
x8 = k4; \
x9 = k5; \
x10 = k6; \
x11 = k7; \
x12 = n0; \
x13 = n1; \
x14 = n2; \
x15 = n3; \
\
TWOROUNDS() /* round 1, 2 */ \
TWOROUNDS() /* round 3, 4 */ \
TWOROUNDS() /* round 5, 6 */ \
TWOROUNDS() /* round 7, 8 */ \
TWOROUNDS() /* round 9, 10 */ \
TWOROUNDS() /* round 11, 12 */ \
TWOROUNDS() /* round 13, 14 */ \
TWOROUNDS() /* round 15, 16 */ \
TWOROUNDS() /* round 17, 18 */ \
TWOROUNDS() /* round 19, 20 */ \
\
pack32(o, (x0 + s0) ^ unpack32(i)); \
pack32(o + 4, (x1 + s1) ^ unpack32(i + 4)); \
pack32(o + 8, (x2 + s2) ^ unpack32(i + 8)); \
pack32(o + 12, (x3 + s3) ^ unpack32(i + 12)); \
pack32(o + 16, (x4 + k0) ^ unpack32(i + 16)); \
pack32(o + 20, (x5 + k1) ^ unpack32(i + 20)); \
pack32(o + 24, (x6 + k2) ^ unpack32(i + 24)); \
pack32(o + 28, (x7 + k3) ^ unpack32(i + 28)); \
pack32(o + 32, (x8 + k4) ^ unpack32(i + 32)); \
pack32(o + 36, (x9 + k5) ^ unpack32(i + 36)); \
pack32(o + 40, (x10 + k6) ^ unpack32(i + 40)); \
pack32(o + 44, (x11 + k7) ^ unpack32(i + 44)); \
pack32(o + 48, (x12 + n0) ^ unpack32(i + 48)); \
pack32(o + 52, (x13 + n1) ^ unpack32(i + 52)); \
pack32(o + 56, (x14 + n2) ^ unpack32(i + 56)); \
pack32(o + 60, (x15 + n3) ^ unpack32(i + 60))
int crypto_stream_chacha20_tinyssh_xor(unsigned char *c, const unsigned char *m,
unsigned long long l,
const unsigned char *n,
const unsigned char *k) {
register uint32_t x0, x1, x2, x3, x4, x5, x6, x7;
register uint32_t x8, x9, x10, x11, x12, x13, x14, x15;
uint32_t k0 = unpack32(k);
uint32_t k1 = unpack32(k + 4);
uint32_t k2 = unpack32(k + 8);
uint32_t k3 = unpack32(k + 12);
uint32_t k4 = unpack32(k + 16);
uint32_t k5 = unpack32(k + 20);
uint32_t k6 = unpack32(k + 24);
uint32_t k7 = unpack32(k + 28);
uint32_t n0 = 0;
uint32_t n1 = 0;
uint32_t n2 = unpack32(n);
uint32_t n3 = unpack32(n + 4);
uint32_t s0 = 0x61707865;
uint32_t s1 = 0x3320646E;
uint32_t s2 = 0x79622D32;
uint32_t s3 = 0x6B206574;
uint64_t u = 0;
if (!l) return 0;
while (l >= 64) {
XORBLOCK(c, m);
n0 = (uint32_t) ++u;
n1 = u >> 32;
l -= 64;
c += 64;
m += 64;
}
if (l) {
unsigned char b[64] = {0};
unsigned long long j;
for (j = 0; j < l; ++j) b[j] = m[j];
XORBLOCK(b, b);
for (j = 0; j < l; ++j) c[j] = b[j];
}
return 0;
}
int crypto_stream_chacha20_tinyssh(unsigned char *c, unsigned long long l,
const unsigned char *n,
const unsigned char *k) {
unsigned long long j;
unsigned char ncopy[8], kcopy[32];
for (j = 0; j < 32; ++j) kcopy[j] = k[j];
for (j = 0; j < 8; ++j) ncopy[j] = n[j];
for (j = 0; j < l; ++j) c[j] = 0;
return crypto_stream_chacha20_tinyssh_xor(c, c, l, ncopy, kcopy);
}
tinyssh-20250126/crypto_stream_chacha20.h 0000664 0000000 0000000 00000002214 14745512304 0020157 0 ustar 00root root 0000000 0000000 #ifndef crypto_stream_chacha20_H
#define crypto_stream_chacha20_H
#define crypto_stream_chacha20_tinyssh_KEYBYTES 32
#define crypto_stream_chacha20_tinyssh_NONCEBYTES 8
extern int crypto_stream_chacha20_tinyssh(unsigned char *, unsigned long long,
const unsigned char *,
const unsigned char *);
extern int crypto_stream_chacha20_tinyssh_xor(unsigned char *,
const unsigned char *,
unsigned long long,
const unsigned char *,
const unsigned char *);
#define crypto_stream_chacha20 crypto_stream_chacha20_tinyssh
#define crypto_stream_chacha20_xor crypto_stream_chacha20_tinyssh_xor
#define crypto_stream_chacha20_KEYBYTES crypto_stream_chacha20_tinyssh_KEYBYTES
#define crypto_stream_chacha20_NONCEBYTES \
crypto_stream_chacha20_tinyssh_NONCEBYTES
#define crypto_stream_chacha20_IMPLEMENTATION "tinyssh"
#define crypto_stream_chacha20_VERSION "-"
#endif
tinyssh-20250126/crypto_verify_16.c 0000664 0000000 0000000 00000000446 14745512304 0017045 0 ustar 00root root 0000000 0000000 #include "crypto_int16.h"
#include "crypto_verify_16.h"
int crypto_verify_16_tinyssh(const unsigned char *x, const unsigned char *y) {
crypto_int16 d = 0;
long long i;
for (i = 0; i < crypto_verify_16_BYTES; ++i) { d |= x[i] ^ y[i]; }
return crypto_int16_nonzero_mask(d);
}
tinyssh-20250126/crypto_verify_16.h 0000664 0000000 0000000 00000000650 14745512304 0017047 0 ustar 00root root 0000000 0000000 #ifndef crypto_verify_16_H
#define crypto_verify_16_H
#define crypto_verify_16_tinyssh_BYTES 16
extern int crypto_verify_16_tinyssh(const unsigned char *,
const unsigned char *);
#define crypto_verify_16 crypto_verify_16_tinyssh
#define crypto_verify_16_BYTES crypto_verify_16_tinyssh_BYTES
#define crypto_verify_16_IMPLEMENTATION "tinyssh"
#define crypto_verify_16_VERSION "-"
#endif
tinyssh-20250126/crypto_verify_32.c 0000664 0000000 0000000 00000000446 14745512304 0017043 0 ustar 00root root 0000000 0000000 #include "crypto_int16.h"
#include "crypto_verify_32.h"
int crypto_verify_32_tinyssh(const unsigned char *x, const unsigned char *y) {
crypto_int16 d = 0;
long long i;
for (i = 0; i < crypto_verify_32_BYTES; ++i) { d |= x[i] ^ y[i]; }
return crypto_int16_nonzero_mask(d);
}
tinyssh-20250126/crypto_verify_32.h 0000664 0000000 0000000 00000000650 14745512304 0017045 0 ustar 00root root 0000000 0000000 #ifndef crypto_verify_32_H
#define crypto_verify_32_H
#define crypto_verify_32_tinyssh_BYTES 32
extern int crypto_verify_32_tinyssh(const unsigned char *,
const unsigned char *);
#define crypto_verify_32 crypto_verify_32_tinyssh
#define crypto_verify_32_BYTES crypto_verify_32_tinyssh_BYTES
#define crypto_verify_32_IMPLEMENTATION "tinyssh"
#define crypto_verify_32_VERSION "-"
#endif
tinyssh-20250126/cryptoint/ 0000775 0000000 0000000 00000000000 14745512304 0015516 5 ustar 00root root 0000000 0000000 tinyssh-20250126/cryptoint/autogen 0000775 0000000 0000000 00000000072 14745512304 0017105 0 ustar 00root root 0000000 0000000 #!/bin/sh
./create.py
./specialize.py
rm -rf __pycache__
tinyssh-20250126/cryptoint/create.py 0000775 0000000 0000000 00000005167 14745512304 0017347 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
vars = 'k','l','p','q','r','s','x','y','z'
with open('version') as f:
version = f.read().strip()
# ===== top
csh = f'''/* auto-generated: cd cryptoint; ./autogen */
/* {version} */
#ifndef crypto_intN_h
#define crypto_intN_h
#include
#define crypto_intN intN_t
#define crypto_intN_unsigned uintN_t
#define crypto_intN_optblocker namespace_intN_optblocker
extern volatile crypto_intN crypto_intN_optblocker;
'''
cuh = f'''/* auto-generated: cd cryptoint; ./autogen */
/* {version} */
#ifndef crypto_uintN_h
#define crypto_uintN_h
#include
#define crypto_uintN uintN_t
#define crypto_uintN_signed intN_t
#define crypto_uintN_signed_optblocker namespace_uintN_signed_optblocker
extern volatile crypto_uintN_signed crypto_uintN_signed_optblocker;
'''
# ===== functions
functions = []
with open('functions') as f:
which,fun = 'both',None
for line in f:
if fun is None:
if line.startswith('#'): continue
if line.strip() == '': continue
if line.strip() == 'SIGNED:':
which = 'signed'
continue
if line.strip() == 'UNSIGNED:':
which = 'unsigned'
continue
fun = ''
fun += line
if line.strip() == '}':
functions += [(which,fun)]
which,fun = 'both',None
for which,fun in functions:
if which in ('both','signed'):
data = fun
data = data.replace('TYPE','crypto_intN')
data = data.replace('UNSIGNED','crypto_intN_unsigned')
data = data.replace('SIGNED','crypto_intN')
for v in vars:
data = data.replace(v.upper(),'crypto_intN_'+v)
csh += '__attribute__((unused))\n'
csh += 'static inline\n'
csh += data
csh += '\n'
if which in ('both','unsigned'):
data = fun
data = data.replace('TYPE','crypto_uintN')
data = data.replace('UNSIGNED','crypto_uintN')
data = data.replace('SIGNED','crypto_uintN_signed')
for v in vars:
data = data.replace(v.upper(),'crypto_uintN_'+v)
cuh += '__attribute__((unused))\n'
cuh += 'static inline\n'
cuh += data
cuh += '\n'
# ===== bottom
csh += '''#endif
'''
cuh += '''#endif
'''
# ===== ship it
with open('crypto_intN.h','w') as f:
f.write(csh)
with open('crypto_uintN.h','w') as f:
f.write(cuh)
with open('intN_optblocker.c','w') as f:
f.write(f'''/* auto-generated: cd cryptoint; ./autogen */
/* {version} */
#include "crypto_intN.h"
volatile crypto_intN crypto_intN_optblocker = 0;
''')
with open('uintN_optblocker.c','w') as f:
f.write(f'''/* auto-generated: cd cryptoint; ./autogen */
/* {version} */
#include "crypto_uintN.h"
volatile crypto_uintN_signed crypto_uintN_signed_optblocker = 0;
''')
tinyssh-20250126/cryptoint/crypto_int16.h 0000664 0000000 0000000 00000052665 14745512304 0020246 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_int16_h
#define crypto_int16_h
#include
#define crypto_int16 int16_t
#define crypto_int16_unsigned uint16_t
#define crypto_int16_optblocker tinyssh_int16_optblocker
extern volatile crypto_int16 crypto_int16_optblocker;
__attribute__((unused))
static inline
crypto_int16 crypto_int16_load(const unsigned char *crypto_int16_s) {
crypto_int16 crypto_int16_z = 0;
crypto_int16_z |= ((crypto_int16) (*crypto_int16_s++)) << 0;
crypto_int16_z |= ((crypto_int16) (*crypto_int16_s++)) << 8;
return crypto_int16_z;
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_load_bigendian(const unsigned char *crypto_int16_s) {
crypto_int16 crypto_int16_z = 0;
crypto_int16_z |= ((crypto_int16) (*crypto_int16_s++)) << 8;
crypto_int16_z |= ((crypto_int16) (*crypto_int16_s++)) << 0;
return crypto_int16_z;
}
__attribute__((unused))
static inline
void crypto_int16_store(unsigned char *crypto_int16_s,crypto_int16 crypto_int16_x) {
*crypto_int16_s++ = crypto_int16_x >> 0;
*crypto_int16_s++ = crypto_int16_x >> 8;
}
__attribute__((unused))
static inline
void crypto_int16_store_bigendian(unsigned char *crypto_int16_s,crypto_int16 crypto_int16_x) {
*crypto_int16_s++ = crypto_int16_x >> 8;
*crypto_int16_s++ = crypto_int16_x >> 0;
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_negative_mask(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarw $15,%0" : "+r"(crypto_int16_x) : : "cc");
return crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_y;
__asm__ ("sbfx %w0,%w1,15,1" : "=r"(crypto_int16_y) : "r"(crypto_int16_x) : );
return crypto_int16_y;
#else
crypto_int16_x >>= 16-6;
crypto_int16_x += crypto_int16_optblocker;
crypto_int16_x >>= 5;
return crypto_int16_x;
#endif
}
__attribute__((unused))
static inline
crypto_int16_unsigned crypto_int16_unsigned_topbit_01(crypto_int16_unsigned crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrw $15,%0" : "+r"(crypto_int16_x) : : "cc");
return crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_y;
__asm__ ("ubfx %w0,%w1,15,1" : "=r"(crypto_int16_y) : "r"(crypto_int16_x) : );
return crypto_int16_y;
#else
crypto_int16_x >>= 16-6;
crypto_int16_x += crypto_int16_optblocker;
crypto_int16_x >>= 5;
return crypto_int16_x;
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_negative_01(crypto_int16 crypto_int16_x) {
return crypto_int16_unsigned_topbit_01(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_topbit_mask(crypto_int16 crypto_int16_x) {
return crypto_int16_negative_mask(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_topbit_01(crypto_int16 crypto_int16_x) {
return crypto_int16_unsigned_topbit_01(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_bottombit_mask(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andw $1,%0" : "+r"(crypto_int16_x) : : "cc");
return -crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_y;
__asm__ ("sbfx %w0,%w1,0,1" : "=r"(crypto_int16_y) : "r"(crypto_int16_x) : );
return crypto_int16_y;
#else
crypto_int16_x &= 1 + crypto_int16_optblocker;
return -crypto_int16_x;
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_bottombit_01(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andw $1,%0" : "+r"(crypto_int16_x) : : "cc");
return crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_y;
__asm__ ("ubfx %w0,%w1,0,1" : "=r"(crypto_int16_y) : "r"(crypto_int16_x) : );
return crypto_int16_y;
#else
crypto_int16_x &= 1 + crypto_int16_optblocker;
return crypto_int16_x;
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_bitinrangepublicpos_mask(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarw %%cl,%0" : "+r"(crypto_int16_x) : "c"(crypto_int16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxth %w0,%w0\n asr %w0,%w0,%w1" : "+&r"(crypto_int16_x) : "r"(crypto_int16_s) : );
#else
crypto_int16_x >>= crypto_int16_s ^ crypto_int16_optblocker;
#endif
return crypto_int16_bottombit_mask(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_bitinrangepublicpos_01(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarw %%cl,%0" : "+r"(crypto_int16_x) : "c"(crypto_int16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxth %w0,%w0\n asr %w0,%w0,%w1" : "+&r"(crypto_int16_x) : "r"(crypto_int16_s) : );
#else
crypto_int16_x >>= crypto_int16_s ^ crypto_int16_optblocker;
#endif
return crypto_int16_bottombit_01(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_shlmod(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16_s &= 15;
__asm__ ("shlw %%cl,%0" : "+r"(crypto_int16_x) : "c"(crypto_int16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,15\n and %w1,%w1,65535\n lsl %w1,%w1,%w0" : "+&r"(crypto_int16_s), "+r"(crypto_int16_x) : : );
#else
int crypto_int16_k, crypto_int16_l;
for (crypto_int16_l = 0,crypto_int16_k = 1;crypto_int16_k < 16;++crypto_int16_l,crypto_int16_k *= 2)
crypto_int16_x ^= (crypto_int16_x ^ (crypto_int16_x << crypto_int16_k)) & crypto_int16_bitinrangepublicpos_mask(crypto_int16_s,crypto_int16_l);
#endif
return crypto_int16_x;
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_shrmod(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16_s &= 15;
__asm__ ("sarw %%cl,%0" : "+r"(crypto_int16_x) : "c"(crypto_int16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,15\n sxth %w1,%w1\n asr %w1,%w1,%w0" : "+&r"(crypto_int16_s), "+r"(crypto_int16_x) : : );
#else
int crypto_int16_k, crypto_int16_l;
for (crypto_int16_l = 0,crypto_int16_k = 1;crypto_int16_k < 16;++crypto_int16_l,crypto_int16_k *= 2)
crypto_int16_x ^= (crypto_int16_x ^ (crypto_int16_x >> crypto_int16_k)) & crypto_int16_bitinrangepublicpos_mask(crypto_int16_s,crypto_int16_l);
#endif
return crypto_int16_x;
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_bitmod_mask(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_s) {
crypto_int16_x = crypto_int16_shrmod(crypto_int16_x,crypto_int16_s);
return crypto_int16_bottombit_mask(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_bitmod_01(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_s) {
crypto_int16_x = crypto_int16_shrmod(crypto_int16_x,crypto_int16_s);
return crypto_int16_bottombit_01(crypto_int16_x);
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_nonzero_mask(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n testw %2,%2\n cmovnew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("tst %w1,65535\n csetm %w0,ne" : "=r"(crypto_int16_z) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#else
crypto_int16_x |= -crypto_int16_x;
return crypto_int16_negative_mask(crypto_int16_x);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_nonzero_01(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n testw %2,%2\n cmovnew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("tst %w1,65535\n cset %w0,ne" : "=r"(crypto_int16_z) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#else
crypto_int16_x |= -crypto_int16_x;
return crypto_int16_unsigned_topbit_01(crypto_int16_x);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_positive_mask(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n testw %2,%2\n cmovgw %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("sxth %w0,%w1\n cmp %w0,0\n csetm %w0,gt" : "=r"(crypto_int16_z) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#else
crypto_int16 crypto_int16_z = -crypto_int16_x;
crypto_int16_z ^= crypto_int16_x & crypto_int16_z;
return crypto_int16_negative_mask(crypto_int16_z);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_positive_01(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n testw %2,%2\n cmovgw %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("sxth %w0,%w1\n cmp %w0,0\n cset %w0,gt" : "=r"(crypto_int16_z) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#else
crypto_int16 crypto_int16_z = -crypto_int16_x;
crypto_int16_z ^= crypto_int16_x & crypto_int16_z;
return crypto_int16_unsigned_topbit_01(crypto_int16_z);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_zero_mask(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n testw %2,%2\n cmovew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("tst %w1,65535\n csetm %w0,eq" : "=r"(crypto_int16_z) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#else
return ~crypto_int16_nonzero_mask(crypto_int16_x);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_zero_01(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n testw %2,%2\n cmovew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("tst %w1,65535\n cset %w0,eq" : "=r"(crypto_int16_z) : "r"(crypto_int16_x) : "cc");
return crypto_int16_z;
#else
return 1-crypto_int16_nonzero_01(crypto_int16_x);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_unequal_mask(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovnew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n csetm %w0,ne" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
return crypto_int16_nonzero_mask(crypto_int16_x ^ crypto_int16_y);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_unequal_01(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovnew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n cset %w0,ne" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
return crypto_int16_nonzero_01(crypto_int16_x ^ crypto_int16_y);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_equal_mask(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n csetm %w0,eq" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
return ~crypto_int16_unequal_mask(crypto_int16_x,crypto_int16_y);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_equal_01(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n cset %w0,eq" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
return 1-crypto_int16_unequal_01(crypto_int16_x,crypto_int16_y);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_min(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpw %1,%0\n cmovgw %1,%0" : "+r"(crypto_int16_x) : "r"(crypto_int16_y) : "cc");
return crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxth %w0,%w0\n cmp %w0,%w1,sxth\n csel %w0,%w0,%w1,lt" : "+&r"(crypto_int16_x) : "r"(crypto_int16_y) : "cc");
return crypto_int16_x;
#else
crypto_int16 crypto_int16_r = crypto_int16_y ^ crypto_int16_x;
crypto_int16 crypto_int16_z = crypto_int16_y - crypto_int16_x;
crypto_int16_z ^= crypto_int16_r & (crypto_int16_z ^ crypto_int16_y);
crypto_int16_z = crypto_int16_negative_mask(crypto_int16_z);
crypto_int16_z &= crypto_int16_r;
return crypto_int16_x ^ crypto_int16_z;
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_max(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpw %1,%0\n cmovlw %1,%0" : "+r"(crypto_int16_x) : "r"(crypto_int16_y) : "cc");
return crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxth %w0,%w0\n cmp %w0,%w1,sxth\n csel %w0,%w1,%w0,lt" : "+&r"(crypto_int16_x) : "r"(crypto_int16_y) : "cc");
return crypto_int16_x;
#else
crypto_int16 crypto_int16_r = crypto_int16_y ^ crypto_int16_x;
crypto_int16 crypto_int16_z = crypto_int16_y - crypto_int16_x;
crypto_int16_z ^= crypto_int16_r & (crypto_int16_z ^ crypto_int16_y);
crypto_int16_z = crypto_int16_negative_mask(crypto_int16_z);
crypto_int16_z &= crypto_int16_r;
return crypto_int16_y ^ crypto_int16_z;
#endif
}
__attribute__((unused))
static inline
void crypto_int16_minmax(crypto_int16 *crypto_int16_p,crypto_int16 *crypto_int16_q) {
crypto_int16 crypto_int16_x = *crypto_int16_p;
crypto_int16 crypto_int16_y = *crypto_int16_q;
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_z;
__asm__ ("cmpw %2,%1\n movw %1,%0\n cmovgw %2,%1\n cmovgw %0,%2" : "=&r"(crypto_int16_z), "+&r"(crypto_int16_x), "+r"(crypto_int16_y) : : "cc");
*crypto_int16_p = crypto_int16_x;
*crypto_int16_q = crypto_int16_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_r, crypto_int16_s;
__asm__ ("sxth %w0,%w0\n cmp %w0,%w3,sxth\n csel %w1,%w0,%w3,lt\n csel %w2,%w3,%w0,lt" : "+&r"(crypto_int16_x), "=&r"(crypto_int16_r), "=r"(crypto_int16_s) : "r"(crypto_int16_y) : "cc");
*crypto_int16_p = crypto_int16_r;
*crypto_int16_q = crypto_int16_s;
#else
crypto_int16 crypto_int16_r = crypto_int16_y ^ crypto_int16_x;
crypto_int16 crypto_int16_z = crypto_int16_y - crypto_int16_x;
crypto_int16_z ^= crypto_int16_r & (crypto_int16_z ^ crypto_int16_y);
crypto_int16_z = crypto_int16_negative_mask(crypto_int16_z);
crypto_int16_z &= crypto_int16_r;
crypto_int16_x ^= crypto_int16_z;
crypto_int16_y ^= crypto_int16_z;
*crypto_int16_p = crypto_int16_x;
*crypto_int16_q = crypto_int16_y;
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_smaller_mask(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovlw %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("sxth %w0,%w1\n cmp %w0,%w2,sxth\n csetm %w0,lt" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
crypto_int16 crypto_int16_r = crypto_int16_x ^ crypto_int16_y;
crypto_int16 crypto_int16_z = crypto_int16_x - crypto_int16_y;
crypto_int16_z ^= crypto_int16_r & (crypto_int16_z ^ crypto_int16_x);
return crypto_int16_negative_mask(crypto_int16_z);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_smaller_01(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovlw %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("sxth %w0,%w1\n cmp %w0,%w2,sxth\n cset %w0,lt" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
crypto_int16 crypto_int16_r = crypto_int16_x ^ crypto_int16_y;
crypto_int16 crypto_int16_z = crypto_int16_x - crypto_int16_y;
crypto_int16_z ^= crypto_int16_r & (crypto_int16_z ^ crypto_int16_x);
return crypto_int16_unsigned_topbit_01(crypto_int16_z);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_leq_mask(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovlew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("sxth %w0,%w1\n cmp %w0,%w2,sxth\n csetm %w0,le" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
return ~crypto_int16_smaller_mask(crypto_int16_y,crypto_int16_x);
#endif
}
__attribute__((unused))
static inline
crypto_int16 crypto_int16_leq_01(crypto_int16 crypto_int16_x,crypto_int16 crypto_int16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 crypto_int16_q,crypto_int16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovlew %1,%0" : "=&r"(crypto_int16_z), "=&r"(crypto_int16_q) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int16 crypto_int16_z;
__asm__ ("sxth %w0,%w1\n cmp %w0,%w2,sxth\n cset %w0,le" : "=&r"(crypto_int16_z) : "r"(crypto_int16_x), "r"(crypto_int16_y) : "cc");
return crypto_int16_z;
#else
return 1-crypto_int16_smaller_01(crypto_int16_y,crypto_int16_x);
#endif
}
__attribute__((unused))
static inline
int crypto_int16_ones_num(crypto_int16 crypto_int16_x) {
crypto_int16_unsigned crypto_int16_y = crypto_int16_x;
const crypto_int16 C0 = 0x5555;
const crypto_int16 C1 = 0x3333;
const crypto_int16 C2 = 0x0f0f;
crypto_int16_y -= ((crypto_int16_y >> 1) & C0);
crypto_int16_y = (crypto_int16_y & C1) + ((crypto_int16_y >> 2) & C1);
crypto_int16_y = (crypto_int16_y + (crypto_int16_y >> 4)) & C2;
crypto_int16_y = (crypto_int16_y + (crypto_int16_y >> 8)) & 0xff;
return crypto_int16_y;
}
__attribute__((unused))
static inline
int crypto_int16_bottomzeros_num(crypto_int16 crypto_int16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int16 fallback = 16;
__asm__ ("bsfw %0,%0\n cmovew %1,%0" : "+&r"(crypto_int16_x) : "r"(fallback) : "cc");
return crypto_int16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_int16_y;
__asm__ ("orr %w0,%w1,-65536\n rbit %w0,%w0\n clz %w0,%w0" : "=r"(crypto_int16_y) : "r"(crypto_int16_x) : );
return crypto_int16_y;
#else
crypto_int16 crypto_int16_y = crypto_int16_x ^ (crypto_int16_x-1);
crypto_int16_y = ((crypto_int16) crypto_int16_y) >> 1;
crypto_int16_y &= ~(crypto_int16_x & (((crypto_int16) 1) << (16-1)));
return crypto_int16_ones_num(crypto_int16_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_int32.h 0000664 0000000 0000000 00000052673 14745512304 0020243 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_int32_h
#define crypto_int32_h
#include
#define crypto_int32 int32_t
#define crypto_int32_unsigned uint32_t
#define crypto_int32_optblocker tinyssh_int32_optblocker
extern volatile crypto_int32 crypto_int32_optblocker;
__attribute__((unused))
static inline
crypto_int32 crypto_int32_load(const unsigned char *crypto_int32_s) {
crypto_int32 crypto_int32_z = 0;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 0;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 8;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 16;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 24;
return crypto_int32_z;
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_load_bigendian(const unsigned char *crypto_int32_s) {
crypto_int32 crypto_int32_z = 0;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 24;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 16;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 8;
crypto_int32_z |= ((crypto_int32) (*crypto_int32_s++)) << 0;
return crypto_int32_z;
}
__attribute__((unused))
static inline
void crypto_int32_store(unsigned char *crypto_int32_s,crypto_int32 crypto_int32_x) {
*crypto_int32_s++ = crypto_int32_x >> 0;
*crypto_int32_s++ = crypto_int32_x >> 8;
*crypto_int32_s++ = crypto_int32_x >> 16;
*crypto_int32_s++ = crypto_int32_x >> 24;
}
__attribute__((unused))
static inline
void crypto_int32_store_bigendian(unsigned char *crypto_int32_s,crypto_int32 crypto_int32_x) {
*crypto_int32_s++ = crypto_int32_x >> 24;
*crypto_int32_s++ = crypto_int32_x >> 16;
*crypto_int32_s++ = crypto_int32_x >> 8;
*crypto_int32_s++ = crypto_int32_x >> 0;
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_negative_mask(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarl $31,%0" : "+r"(crypto_int32_x) : : "cc");
return crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_y;
__asm__ ("asr %w0,%w1,31" : "=r"(crypto_int32_y) : "r"(crypto_int32_x) : );
return crypto_int32_y;
#else
crypto_int32_x >>= 32-6;
crypto_int32_x += crypto_int32_optblocker;
crypto_int32_x >>= 5;
return crypto_int32_x;
#endif
}
__attribute__((unused))
static inline
crypto_int32_unsigned crypto_int32_unsigned_topbit_01(crypto_int32_unsigned crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrl $31,%0" : "+r"(crypto_int32_x) : : "cc");
return crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_y;
__asm__ ("lsr %w0,%w1,31" : "=r"(crypto_int32_y) : "r"(crypto_int32_x) : );
return crypto_int32_y;
#else
crypto_int32_x >>= 32-6;
crypto_int32_x += crypto_int32_optblocker;
crypto_int32_x >>= 5;
return crypto_int32_x;
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_negative_01(crypto_int32 crypto_int32_x) {
return crypto_int32_unsigned_topbit_01(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_topbit_mask(crypto_int32 crypto_int32_x) {
return crypto_int32_negative_mask(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_topbit_01(crypto_int32 crypto_int32_x) {
return crypto_int32_unsigned_topbit_01(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_bottombit_mask(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andl $1,%0" : "+r"(crypto_int32_x) : : "cc");
return -crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_y;
__asm__ ("sbfx %w0,%w1,0,1" : "=r"(crypto_int32_y) : "r"(crypto_int32_x) : );
return crypto_int32_y;
#else
crypto_int32_x &= 1 + crypto_int32_optblocker;
return -crypto_int32_x;
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_bottombit_01(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andl $1,%0" : "+r"(crypto_int32_x) : : "cc");
return crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_y;
__asm__ ("ubfx %w0,%w1,0,1" : "=r"(crypto_int32_y) : "r"(crypto_int32_x) : );
return crypto_int32_y;
#else
crypto_int32_x &= 1 + crypto_int32_optblocker;
return crypto_int32_x;
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_bitinrangepublicpos_mask(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarl %%cl,%0" : "+r"(crypto_int32_x) : "c"(crypto_int32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("asr %w0,%w0,%w1" : "+r"(crypto_int32_x) : "r"(crypto_int32_s) : );
#else
crypto_int32_x >>= crypto_int32_s ^ crypto_int32_optblocker;
#endif
return crypto_int32_bottombit_mask(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_bitinrangepublicpos_01(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarl %%cl,%0" : "+r"(crypto_int32_x) : "c"(crypto_int32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("asr %w0,%w0,%w1" : "+r"(crypto_int32_x) : "r"(crypto_int32_s) : );
#else
crypto_int32_x >>= crypto_int32_s ^ crypto_int32_optblocker;
#endif
return crypto_int32_bottombit_01(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_shlmod(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shll %%cl,%0" : "+r"(crypto_int32_x) : "c"(crypto_int32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsl %w0,%w0,%w1" : "+r"(crypto_int32_x) : "r"(crypto_int32_s) : );
#else
int crypto_int32_k, crypto_int32_l;
for (crypto_int32_l = 0,crypto_int32_k = 1;crypto_int32_k < 32;++crypto_int32_l,crypto_int32_k *= 2)
crypto_int32_x ^= (crypto_int32_x ^ (crypto_int32_x << crypto_int32_k)) & crypto_int32_bitinrangepublicpos_mask(crypto_int32_s,crypto_int32_l);
#endif
return crypto_int32_x;
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_shrmod(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarl %%cl,%0" : "+r"(crypto_int32_x) : "c"(crypto_int32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("asr %w0,%w0,%w1" : "+r"(crypto_int32_x) : "r"(crypto_int32_s) : );
#else
int crypto_int32_k, crypto_int32_l;
for (crypto_int32_l = 0,crypto_int32_k = 1;crypto_int32_k < 32;++crypto_int32_l,crypto_int32_k *= 2)
crypto_int32_x ^= (crypto_int32_x ^ (crypto_int32_x >> crypto_int32_k)) & crypto_int32_bitinrangepublicpos_mask(crypto_int32_s,crypto_int32_l);
#endif
return crypto_int32_x;
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_bitmod_mask(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_s) {
crypto_int32_x = crypto_int32_shrmod(crypto_int32_x,crypto_int32_s);
return crypto_int32_bottombit_mask(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_bitmod_01(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_s) {
crypto_int32_x = crypto_int32_shrmod(crypto_int32_x,crypto_int32_s);
return crypto_int32_bottombit_01(crypto_int32_x);
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_nonzero_mask(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testl %2,%2\n cmovnel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,0\n csetm %w0,ne" : "=r"(crypto_int32_z) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#else
crypto_int32_x |= -crypto_int32_x;
return crypto_int32_negative_mask(crypto_int32_x);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_nonzero_01(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n testl %2,%2\n cmovnel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,0\n cset %w0,ne" : "=r"(crypto_int32_z) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#else
crypto_int32_x |= -crypto_int32_x;
return crypto_int32_unsigned_topbit_01(crypto_int32_x);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_positive_mask(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testl %2,%2\n cmovgl %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,0\n csetm %w0,gt" : "=r"(crypto_int32_z) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#else
crypto_int32 crypto_int32_z = -crypto_int32_x;
crypto_int32_z ^= crypto_int32_x & crypto_int32_z;
return crypto_int32_negative_mask(crypto_int32_z);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_positive_01(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n testl %2,%2\n cmovgl %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,0\n cset %w0,gt" : "=r"(crypto_int32_z) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#else
crypto_int32 crypto_int32_z = -crypto_int32_x;
crypto_int32_z ^= crypto_int32_x & crypto_int32_z;
return crypto_int32_unsigned_topbit_01(crypto_int32_z);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_zero_mask(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testl %2,%2\n cmovel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,0\n csetm %w0,eq" : "=r"(crypto_int32_z) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#else
return ~crypto_int32_nonzero_mask(crypto_int32_x);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_zero_01(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n testl %2,%2\n cmovel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,0\n cset %w0,eq" : "=r"(crypto_int32_z) : "r"(crypto_int32_x) : "cc");
return crypto_int32_z;
#else
return 1-crypto_int32_nonzero_01(crypto_int32_x);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_unequal_mask(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovnel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,ne" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
return crypto_int32_nonzero_mask(crypto_int32_x ^ crypto_int32_y);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_unequal_01(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovnel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,ne" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
return crypto_int32_nonzero_01(crypto_int32_x ^ crypto_int32_y);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_equal_mask(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,eq" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
return ~crypto_int32_unequal_mask(crypto_int32_x,crypto_int32_y);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_equal_01(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,eq" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
return 1-crypto_int32_unequal_01(crypto_int32_x,crypto_int32_y);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_min(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpl %1,%0\n cmovgl %1,%0" : "+r"(crypto_int32_x) : "r"(crypto_int32_y) : "cc");
return crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %w0,%w1\n csel %w0,%w0,%w1,lt" : "+r"(crypto_int32_x) : "r"(crypto_int32_y) : "cc");
return crypto_int32_x;
#else
crypto_int32 crypto_int32_r = crypto_int32_y ^ crypto_int32_x;
crypto_int32 crypto_int32_z = crypto_int32_y - crypto_int32_x;
crypto_int32_z ^= crypto_int32_r & (crypto_int32_z ^ crypto_int32_y);
crypto_int32_z = crypto_int32_negative_mask(crypto_int32_z);
crypto_int32_z &= crypto_int32_r;
return crypto_int32_x ^ crypto_int32_z;
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_max(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpl %1,%0\n cmovll %1,%0" : "+r"(crypto_int32_x) : "r"(crypto_int32_y) : "cc");
return crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %w0,%w1\n csel %w0,%w1,%w0,lt" : "+r"(crypto_int32_x) : "r"(crypto_int32_y) : "cc");
return crypto_int32_x;
#else
crypto_int32 crypto_int32_r = crypto_int32_y ^ crypto_int32_x;
crypto_int32 crypto_int32_z = crypto_int32_y - crypto_int32_x;
crypto_int32_z ^= crypto_int32_r & (crypto_int32_z ^ crypto_int32_y);
crypto_int32_z = crypto_int32_negative_mask(crypto_int32_z);
crypto_int32_z &= crypto_int32_r;
return crypto_int32_y ^ crypto_int32_z;
#endif
}
__attribute__((unused))
static inline
void crypto_int32_minmax(crypto_int32 *crypto_int32_p,crypto_int32 *crypto_int32_q) {
crypto_int32 crypto_int32_x = *crypto_int32_p;
crypto_int32 crypto_int32_y = *crypto_int32_q;
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmpl %2,%1\n movl %1,%0\n cmovgl %2,%1\n cmovgl %0,%2" : "=&r"(crypto_int32_z), "+&r"(crypto_int32_x), "+r"(crypto_int32_y) : : "cc");
*crypto_int32_p = crypto_int32_x;
*crypto_int32_q = crypto_int32_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_r, crypto_int32_s;
__asm__ ("cmp %w2,%w3\n csel %w0,%w2,%w3,lt\n csel %w1,%w3,%w2,lt" : "=&r"(crypto_int32_r), "=r"(crypto_int32_s) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
*crypto_int32_p = crypto_int32_r;
*crypto_int32_q = crypto_int32_s;
#else
crypto_int32 crypto_int32_r = crypto_int32_y ^ crypto_int32_x;
crypto_int32 crypto_int32_z = crypto_int32_y - crypto_int32_x;
crypto_int32_z ^= crypto_int32_r & (crypto_int32_z ^ crypto_int32_y);
crypto_int32_z = crypto_int32_negative_mask(crypto_int32_z);
crypto_int32_z &= crypto_int32_r;
crypto_int32_x ^= crypto_int32_z;
crypto_int32_y ^= crypto_int32_z;
*crypto_int32_p = crypto_int32_x;
*crypto_int32_q = crypto_int32_y;
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_smaller_mask(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovll %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,lt" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
crypto_int32 crypto_int32_r = crypto_int32_x ^ crypto_int32_y;
crypto_int32 crypto_int32_z = crypto_int32_x - crypto_int32_y;
crypto_int32_z ^= crypto_int32_r & (crypto_int32_z ^ crypto_int32_x);
return crypto_int32_negative_mask(crypto_int32_z);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_smaller_01(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovll %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,lt" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
crypto_int32 crypto_int32_r = crypto_int32_x ^ crypto_int32_y;
crypto_int32 crypto_int32_z = crypto_int32_x - crypto_int32_y;
crypto_int32_z ^= crypto_int32_r & (crypto_int32_z ^ crypto_int32_x);
return crypto_int32_unsigned_topbit_01(crypto_int32_z);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_leq_mask(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovlel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,le" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
return ~crypto_int32_smaller_mask(crypto_int32_y,crypto_int32_x);
#endif
}
__attribute__((unused))
static inline
crypto_int32 crypto_int32_leq_01(crypto_int32 crypto_int32_x,crypto_int32 crypto_int32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 crypto_int32_q,crypto_int32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovlel %1,%0" : "=&r"(crypto_int32_z), "=&r"(crypto_int32_q) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int32 crypto_int32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,le" : "=r"(crypto_int32_z) : "r"(crypto_int32_x), "r"(crypto_int32_y) : "cc");
return crypto_int32_z;
#else
return 1-crypto_int32_smaller_01(crypto_int32_y,crypto_int32_x);
#endif
}
__attribute__((unused))
static inline
int crypto_int32_ones_num(crypto_int32 crypto_int32_x) {
crypto_int32_unsigned crypto_int32_y = crypto_int32_x;
const crypto_int32 C0 = 0x55555555;
const crypto_int32 C1 = 0x33333333;
const crypto_int32 C2 = 0x0f0f0f0f;
crypto_int32_y -= ((crypto_int32_y >> 1) & C0);
crypto_int32_y = (crypto_int32_y & C1) + ((crypto_int32_y >> 2) & C1);
crypto_int32_y = (crypto_int32_y + (crypto_int32_y >> 4)) & C2;
crypto_int32_y += crypto_int32_y >> 8;
crypto_int32_y = (crypto_int32_y + (crypto_int32_y >> 16)) & 0xff;
return crypto_int32_y;
}
__attribute__((unused))
static inline
int crypto_int32_bottomzeros_num(crypto_int32 crypto_int32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int32 fallback = 32;
__asm__ ("bsfl %0,%0\n cmovel %1,%0" : "+&r"(crypto_int32_x) : "r"(fallback) : "cc");
return crypto_int32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_int32_y;
__asm__ ("rbit %w0,%w1\n clz %w0,%w0" : "=r"(crypto_int32_y) : "r"(crypto_int32_x) : );
return crypto_int32_y;
#else
crypto_int32 crypto_int32_y = crypto_int32_x ^ (crypto_int32_x-1);
crypto_int32_y = ((crypto_int32) crypto_int32_y) >> 1;
crypto_int32_y &= ~(crypto_int32_x & (((crypto_int32) 1) << (32-1)));
return crypto_int32_ones_num(crypto_int32_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_int64.h 0000664 0000000 0000000 00000054417 14745512304 0020246 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_int64_h
#define crypto_int64_h
#include
#define crypto_int64 int64_t
#define crypto_int64_unsigned uint64_t
#define crypto_int64_optblocker tinyssh_int64_optblocker
extern volatile crypto_int64 crypto_int64_optblocker;
__attribute__((unused))
static inline
crypto_int64 crypto_int64_load(const unsigned char *crypto_int64_s) {
crypto_int64 crypto_int64_z = 0;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 0;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 8;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 16;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 24;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 32;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 40;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 48;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 56;
return crypto_int64_z;
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_load_bigendian(const unsigned char *crypto_int64_s) {
crypto_int64 crypto_int64_z = 0;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 56;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 48;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 40;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 32;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 24;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 16;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 8;
crypto_int64_z |= ((crypto_int64) (*crypto_int64_s++)) << 0;
return crypto_int64_z;
}
__attribute__((unused))
static inline
void crypto_int64_store(unsigned char *crypto_int64_s,crypto_int64 crypto_int64_x) {
*crypto_int64_s++ = crypto_int64_x >> 0;
*crypto_int64_s++ = crypto_int64_x >> 8;
*crypto_int64_s++ = crypto_int64_x >> 16;
*crypto_int64_s++ = crypto_int64_x >> 24;
*crypto_int64_s++ = crypto_int64_x >> 32;
*crypto_int64_s++ = crypto_int64_x >> 40;
*crypto_int64_s++ = crypto_int64_x >> 48;
*crypto_int64_s++ = crypto_int64_x >> 56;
}
__attribute__((unused))
static inline
void crypto_int64_store_bigendian(unsigned char *crypto_int64_s,crypto_int64 crypto_int64_x) {
*crypto_int64_s++ = crypto_int64_x >> 56;
*crypto_int64_s++ = crypto_int64_x >> 48;
*crypto_int64_s++ = crypto_int64_x >> 40;
*crypto_int64_s++ = crypto_int64_x >> 32;
*crypto_int64_s++ = crypto_int64_x >> 24;
*crypto_int64_s++ = crypto_int64_x >> 16;
*crypto_int64_s++ = crypto_int64_x >> 8;
*crypto_int64_s++ = crypto_int64_x >> 0;
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_negative_mask(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarq $63,%0" : "+r"(crypto_int64_x) : : "cc");
return crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_y;
__asm__ ("asr %0,%1,63" : "=r"(crypto_int64_y) : "r"(crypto_int64_x) : );
return crypto_int64_y;
#else
crypto_int64_x >>= 64-6;
crypto_int64_x += crypto_int64_optblocker;
crypto_int64_x >>= 5;
return crypto_int64_x;
#endif
}
__attribute__((unused))
static inline
crypto_int64_unsigned crypto_int64_unsigned_topbit_01(crypto_int64_unsigned crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrq $63,%0" : "+r"(crypto_int64_x) : : "cc");
return crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_y;
__asm__ ("lsr %0,%1,63" : "=r"(crypto_int64_y) : "r"(crypto_int64_x) : );
return crypto_int64_y;
#else
crypto_int64_x >>= 64-6;
crypto_int64_x += crypto_int64_optblocker;
crypto_int64_x >>= 5;
return crypto_int64_x;
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_negative_01(crypto_int64 crypto_int64_x) {
return crypto_int64_unsigned_topbit_01(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_topbit_mask(crypto_int64 crypto_int64_x) {
return crypto_int64_negative_mask(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_topbit_01(crypto_int64 crypto_int64_x) {
return crypto_int64_unsigned_topbit_01(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_bottombit_mask(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andq $1,%0" : "+r"(crypto_int64_x) : : "cc");
return -crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_y;
__asm__ ("sbfx %0,%1,0,1" : "=r"(crypto_int64_y) : "r"(crypto_int64_x) : );
return crypto_int64_y;
#else
crypto_int64_x &= 1 + crypto_int64_optblocker;
return -crypto_int64_x;
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_bottombit_01(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andq $1,%0" : "+r"(crypto_int64_x) : : "cc");
return crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_y;
__asm__ ("ubfx %0,%1,0,1" : "=r"(crypto_int64_y) : "r"(crypto_int64_x) : );
return crypto_int64_y;
#else
crypto_int64_x &= 1 + crypto_int64_optblocker;
return crypto_int64_x;
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_bitinrangepublicpos_mask(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarq %%cl,%0" : "+r"(crypto_int64_x) : "c"(crypto_int64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("asr %0,%0,%1" : "+r"(crypto_int64_x) : "r"(crypto_int64_s) : );
#else
crypto_int64_x >>= crypto_int64_s ^ crypto_int64_optblocker;
#endif
return crypto_int64_bottombit_mask(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_bitinrangepublicpos_01(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarq %%cl,%0" : "+r"(crypto_int64_x) : "c"(crypto_int64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("asr %0,%0,%1" : "+r"(crypto_int64_x) : "r"(crypto_int64_s) : );
#else
crypto_int64_x >>= crypto_int64_s ^ crypto_int64_optblocker;
#endif
return crypto_int64_bottombit_01(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_shlmod(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shlq %%cl,%0" : "+r"(crypto_int64_x) : "c"(crypto_int64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsl %0,%0,%1" : "+r"(crypto_int64_x) : "r"(crypto_int64_s) : );
#else
int crypto_int64_k, crypto_int64_l;
for (crypto_int64_l = 0,crypto_int64_k = 1;crypto_int64_k < 64;++crypto_int64_l,crypto_int64_k *= 2)
crypto_int64_x ^= (crypto_int64_x ^ (crypto_int64_x << crypto_int64_k)) & crypto_int64_bitinrangepublicpos_mask(crypto_int64_s,crypto_int64_l);
#endif
return crypto_int64_x;
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_shrmod(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarq %%cl,%0" : "+r"(crypto_int64_x) : "c"(crypto_int64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("asr %0,%0,%1" : "+r"(crypto_int64_x) : "r"(crypto_int64_s) : );
#else
int crypto_int64_k, crypto_int64_l;
for (crypto_int64_l = 0,crypto_int64_k = 1;crypto_int64_k < 64;++crypto_int64_l,crypto_int64_k *= 2)
crypto_int64_x ^= (crypto_int64_x ^ (crypto_int64_x >> crypto_int64_k)) & crypto_int64_bitinrangepublicpos_mask(crypto_int64_s,crypto_int64_l);
#endif
return crypto_int64_x;
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_bitmod_mask(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_s) {
crypto_int64_x = crypto_int64_shrmod(crypto_int64_x,crypto_int64_s);
return crypto_int64_bottombit_mask(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_bitmod_01(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_s) {
crypto_int64_x = crypto_int64_shrmod(crypto_int64_x,crypto_int64_s);
return crypto_int64_bottombit_01(crypto_int64_x);
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_nonzero_mask(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n testq %2,%2\n cmovneq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,0\n csetm %0,ne" : "=r"(crypto_int64_z) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#else
crypto_int64_x |= -crypto_int64_x;
return crypto_int64_negative_mask(crypto_int64_x);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_nonzero_01(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n testq %2,%2\n cmovneq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,0\n cset %0,ne" : "=r"(crypto_int64_z) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#else
crypto_int64_x |= -crypto_int64_x;
return crypto_int64_unsigned_topbit_01(crypto_int64_x);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_positive_mask(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n testq %2,%2\n cmovgq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,0\n csetm %0,gt" : "=r"(crypto_int64_z) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#else
crypto_int64 crypto_int64_z = -crypto_int64_x;
crypto_int64_z ^= crypto_int64_x & crypto_int64_z;
return crypto_int64_negative_mask(crypto_int64_z);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_positive_01(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n testq %2,%2\n cmovgq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,0\n cset %0,gt" : "=r"(crypto_int64_z) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#else
crypto_int64 crypto_int64_z = -crypto_int64_x;
crypto_int64_z ^= crypto_int64_x & crypto_int64_z;
return crypto_int64_unsigned_topbit_01(crypto_int64_z);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_zero_mask(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n testq %2,%2\n cmoveq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,0\n csetm %0,eq" : "=r"(crypto_int64_z) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#else
return ~crypto_int64_nonzero_mask(crypto_int64_x);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_zero_01(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n testq %2,%2\n cmoveq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,0\n cset %0,eq" : "=r"(crypto_int64_z) : "r"(crypto_int64_x) : "cc");
return crypto_int64_z;
#else
return 1-crypto_int64_nonzero_01(crypto_int64_x);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_unequal_mask(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmovneq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n csetm %0,ne" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
return crypto_int64_nonzero_mask(crypto_int64_x ^ crypto_int64_y);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_unequal_01(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmovneq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n cset %0,ne" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
return crypto_int64_nonzero_01(crypto_int64_x ^ crypto_int64_y);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_equal_mask(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmoveq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n csetm %0,eq" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
return ~crypto_int64_unequal_mask(crypto_int64_x,crypto_int64_y);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_equal_01(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmoveq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n cset %0,eq" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
return 1-crypto_int64_unequal_01(crypto_int64_x,crypto_int64_y);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_min(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpq %1,%0\n cmovgq %1,%0" : "+r"(crypto_int64_x) : "r"(crypto_int64_y) : "cc");
return crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %0,%1\n csel %0,%0,%1,lt" : "+r"(crypto_int64_x) : "r"(crypto_int64_y) : "cc");
return crypto_int64_x;
#else
crypto_int64 crypto_int64_r = crypto_int64_y ^ crypto_int64_x;
crypto_int64 crypto_int64_z = crypto_int64_y - crypto_int64_x;
crypto_int64_z ^= crypto_int64_r & (crypto_int64_z ^ crypto_int64_y);
crypto_int64_z = crypto_int64_negative_mask(crypto_int64_z);
crypto_int64_z &= crypto_int64_r;
return crypto_int64_x ^ crypto_int64_z;
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_max(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpq %1,%0\n cmovlq %1,%0" : "+r"(crypto_int64_x) : "r"(crypto_int64_y) : "cc");
return crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %0,%1\n csel %0,%1,%0,lt" : "+r"(crypto_int64_x) : "r"(crypto_int64_y) : "cc");
return crypto_int64_x;
#else
crypto_int64 crypto_int64_r = crypto_int64_y ^ crypto_int64_x;
crypto_int64 crypto_int64_z = crypto_int64_y - crypto_int64_x;
crypto_int64_z ^= crypto_int64_r & (crypto_int64_z ^ crypto_int64_y);
crypto_int64_z = crypto_int64_negative_mask(crypto_int64_z);
crypto_int64_z &= crypto_int64_r;
return crypto_int64_y ^ crypto_int64_z;
#endif
}
__attribute__((unused))
static inline
void crypto_int64_minmax(crypto_int64 *crypto_int64_p,crypto_int64 *crypto_int64_q) {
crypto_int64 crypto_int64_x = *crypto_int64_p;
crypto_int64 crypto_int64_y = *crypto_int64_q;
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmpq %2,%1\n movq %1,%0\n cmovgq %2,%1\n cmovgq %0,%2" : "=&r"(crypto_int64_z), "+&r"(crypto_int64_x), "+r"(crypto_int64_y) : : "cc");
*crypto_int64_p = crypto_int64_x;
*crypto_int64_q = crypto_int64_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_r, crypto_int64_s;
__asm__ ("cmp %2,%3\n csel %0,%2,%3,lt\n csel %1,%3,%2,lt" : "=&r"(crypto_int64_r), "=r"(crypto_int64_s) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
*crypto_int64_p = crypto_int64_r;
*crypto_int64_q = crypto_int64_s;
#else
crypto_int64 crypto_int64_r = crypto_int64_y ^ crypto_int64_x;
crypto_int64 crypto_int64_z = crypto_int64_y - crypto_int64_x;
crypto_int64_z ^= crypto_int64_r & (crypto_int64_z ^ crypto_int64_y);
crypto_int64_z = crypto_int64_negative_mask(crypto_int64_z);
crypto_int64_z &= crypto_int64_r;
crypto_int64_x ^= crypto_int64_z;
crypto_int64_y ^= crypto_int64_z;
*crypto_int64_p = crypto_int64_x;
*crypto_int64_q = crypto_int64_y;
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_smaller_mask(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmovlq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n csetm %0,lt" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
crypto_int64 crypto_int64_r = crypto_int64_x ^ crypto_int64_y;
crypto_int64 crypto_int64_z = crypto_int64_x - crypto_int64_y;
crypto_int64_z ^= crypto_int64_r & (crypto_int64_z ^ crypto_int64_x);
return crypto_int64_negative_mask(crypto_int64_z);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_smaller_01(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmovlq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n cset %0,lt" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
crypto_int64 crypto_int64_r = crypto_int64_x ^ crypto_int64_y;
crypto_int64 crypto_int64_z = crypto_int64_x - crypto_int64_y;
crypto_int64_z ^= crypto_int64_r & (crypto_int64_z ^ crypto_int64_x);
return crypto_int64_unsigned_topbit_01(crypto_int64_z);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_leq_mask(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmovleq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n csetm %0,le" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
return ~crypto_int64_smaller_mask(crypto_int64_y,crypto_int64_x);
#endif
}
__attribute__((unused))
static inline
crypto_int64 crypto_int64_leq_01(crypto_int64 crypto_int64_x,crypto_int64 crypto_int64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 crypto_int64_q,crypto_int64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmovleq %1,%0" : "=&r"(crypto_int64_z), "=&r"(crypto_int64_q) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int64 crypto_int64_z;
__asm__ ("cmp %1,%2\n cset %0,le" : "=r"(crypto_int64_z) : "r"(crypto_int64_x), "r"(crypto_int64_y) : "cc");
return crypto_int64_z;
#else
return 1-crypto_int64_smaller_01(crypto_int64_y,crypto_int64_x);
#endif
}
__attribute__((unused))
static inline
int crypto_int64_ones_num(crypto_int64 crypto_int64_x) {
crypto_int64_unsigned crypto_int64_y = crypto_int64_x;
const crypto_int64 C0 = 0x5555555555555555;
const crypto_int64 C1 = 0x3333333333333333;
const crypto_int64 C2 = 0x0f0f0f0f0f0f0f0f;
crypto_int64_y -= ((crypto_int64_y >> 1) & C0);
crypto_int64_y = (crypto_int64_y & C1) + ((crypto_int64_y >> 2) & C1);
crypto_int64_y = (crypto_int64_y + (crypto_int64_y >> 4)) & C2;
crypto_int64_y += crypto_int64_y >> 8;
crypto_int64_y += crypto_int64_y >> 16;
crypto_int64_y = (crypto_int64_y + (crypto_int64_y >> 32)) & 0xff;
return crypto_int64_y;
}
__attribute__((unused))
static inline
int crypto_int64_bottomzeros_num(crypto_int64 crypto_int64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int64 fallback = 64;
__asm__ ("bsfq %0,%0\n cmoveq %1,%0" : "+&r"(crypto_int64_x) : "r"(fallback) : "cc");
return crypto_int64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_int64_y;
__asm__ ("rbit %0,%1\n clz %0,%0" : "=r"(crypto_int64_y) : "r"(crypto_int64_x) : );
return crypto_int64_y;
#else
crypto_int64 crypto_int64_y = crypto_int64_x ^ (crypto_int64_x-1);
crypto_int64_y = ((crypto_int64) crypto_int64_y) >> 1;
crypto_int64_y &= ~(crypto_int64_x & (((crypto_int64) 1) << (64-1)));
return crypto_int64_ones_num(crypto_int64_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_int8.h 0000664 0000000 0000000 00000055053 14745512304 0020161 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_int8_h
#define crypto_int8_h
#include
#define crypto_int8 int8_t
#define crypto_int8_unsigned uint8_t
#define crypto_int8_optblocker tinyssh_int8_optblocker
extern volatile crypto_int8 crypto_int8_optblocker;
__attribute__((unused))
static inline
crypto_int8 crypto_int8_load(const unsigned char *crypto_int8_s) {
crypto_int8 crypto_int8_z = 0;
crypto_int8_z |= ((crypto_int8) (*crypto_int8_s++)) << 0;
return crypto_int8_z;
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_load_bigendian(const unsigned char *crypto_int8_s) {
crypto_int8 crypto_int8_z = 0;
crypto_int8_z |= ((crypto_int8) (*crypto_int8_s++)) << 0;
return crypto_int8_z;
}
__attribute__((unused))
static inline
void crypto_int8_store(unsigned char *crypto_int8_s,crypto_int8 crypto_int8_x) {
*crypto_int8_s++ = crypto_int8_x >> 0;
}
__attribute__((unused))
static inline
void crypto_int8_store_bigendian(unsigned char *crypto_int8_s,crypto_int8 crypto_int8_x) {
*crypto_int8_s++ = crypto_int8_x >> 0;
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_negative_mask(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarb $7,%0" : "+r"(crypto_int8_x) : : "cc");
return crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_y;
__asm__ ("sbfx %w0,%w1,7,1" : "=r"(crypto_int8_y) : "r"(crypto_int8_x) : );
return crypto_int8_y;
#else
crypto_int8_x >>= 8-6;
crypto_int8_x += crypto_int8_optblocker;
crypto_int8_x >>= 5;
return crypto_int8_x;
#endif
}
__attribute__((unused))
static inline
crypto_int8_unsigned crypto_int8_unsigned_topbit_01(crypto_int8_unsigned crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrb $7,%0" : "+r"(crypto_int8_x) : : "cc");
return crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_y;
__asm__ ("ubfx %w0,%w1,7,1" : "=r"(crypto_int8_y) : "r"(crypto_int8_x) : );
return crypto_int8_y;
#else
crypto_int8_x >>= 8-6;
crypto_int8_x += crypto_int8_optblocker;
crypto_int8_x >>= 5;
return crypto_int8_x;
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_negative_01(crypto_int8 crypto_int8_x) {
return crypto_int8_unsigned_topbit_01(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_topbit_mask(crypto_int8 crypto_int8_x) {
return crypto_int8_negative_mask(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_topbit_01(crypto_int8 crypto_int8_x) {
return crypto_int8_unsigned_topbit_01(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_bottombit_mask(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andb $1,%0" : "+r"(crypto_int8_x) : : "cc");
return -crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_y;
__asm__ ("sbfx %w0,%w1,0,1" : "=r"(crypto_int8_y) : "r"(crypto_int8_x) : );
return crypto_int8_y;
#else
crypto_int8_x &= 1 + crypto_int8_optblocker;
return -crypto_int8_x;
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_bottombit_01(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andb $1,%0" : "+r"(crypto_int8_x) : : "cc");
return crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_y;
__asm__ ("ubfx %w0,%w1,0,1" : "=r"(crypto_int8_y) : "r"(crypto_int8_x) : );
return crypto_int8_y;
#else
crypto_int8_x &= 1 + crypto_int8_optblocker;
return crypto_int8_x;
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_bitinrangepublicpos_mask(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarb %%cl,%0" : "+r"(crypto_int8_x) : "c"(crypto_int8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxtb %w0,%w0\n asr %w0,%w0,%w1" : "+&r"(crypto_int8_x) : "r"(crypto_int8_s) : );
#else
crypto_int8_x >>= crypto_int8_s ^ crypto_int8_optblocker;
#endif
return crypto_int8_bottombit_mask(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_bitinrangepublicpos_01(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarb %%cl,%0" : "+r"(crypto_int8_x) : "c"(crypto_int8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxtb %w0,%w0\n asr %w0,%w0,%w1" : "+&r"(crypto_int8_x) : "r"(crypto_int8_s) : );
#else
crypto_int8_x >>= crypto_int8_s ^ crypto_int8_optblocker;
#endif
return crypto_int8_bottombit_01(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_shlmod(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8_s &= 7;
__asm__ ("shlb %%cl,%0" : "+r"(crypto_int8_x) : "c"(crypto_int8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,7\n and %w1,%w1,255\n lsl %w1,%w1,%w0" : "+&r"(crypto_int8_s), "+r"(crypto_int8_x) : : );
#else
int crypto_int8_k, crypto_int8_l;
for (crypto_int8_l = 0,crypto_int8_k = 1;crypto_int8_k < 8;++crypto_int8_l,crypto_int8_k *= 2)
crypto_int8_x ^= (crypto_int8_x ^ (crypto_int8_x << crypto_int8_k)) & crypto_int8_bitinrangepublicpos_mask(crypto_int8_s,crypto_int8_l);
#endif
return crypto_int8_x;
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_shrmod(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8_s &= 7;
__asm__ ("sarb %%cl,%0" : "+r"(crypto_int8_x) : "c"(crypto_int8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,7\n sxtb %w1,%w1\n asr %w1,%w1,%w0" : "+&r"(crypto_int8_s), "+r"(crypto_int8_x) : : );
#else
int crypto_int8_k, crypto_int8_l;
for (crypto_int8_l = 0,crypto_int8_k = 1;crypto_int8_k < 8;++crypto_int8_l,crypto_int8_k *= 2)
crypto_int8_x ^= (crypto_int8_x ^ (crypto_int8_x >> crypto_int8_k)) & crypto_int8_bitinrangepublicpos_mask(crypto_int8_s,crypto_int8_l);
#endif
return crypto_int8_x;
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_bitmod_mask(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_s) {
crypto_int8_x = crypto_int8_shrmod(crypto_int8_x,crypto_int8_s);
return crypto_int8_bottombit_mask(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_bitmod_01(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_s) {
crypto_int8_x = crypto_int8_shrmod(crypto_int8_x,crypto_int8_s);
return crypto_int8_bottombit_01(crypto_int8_x);
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_nonzero_mask(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testb %b2,%b2\n cmovnel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("tst %w1,255\n csetm %w0,ne" : "=r"(crypto_int8_z) : "r"(crypto_int8_x) : "cc");
return crypto_int8_z;
#else
crypto_int8_x |= -crypto_int8_x;
return crypto_int8_negative_mask(crypto_int8_x);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_nonzero_01(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n testb %b2,%b2\n cmovnel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("tst %w1,255\n cset %w0,ne" : "=r"(crypto_int8_z) : "r"(crypto_int8_x) : "cc");
return crypto_int8_z;
#else
crypto_int8_x |= -crypto_int8_x;
return crypto_int8_unsigned_topbit_01(crypto_int8_x);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_positive_mask(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testb %b2,%b2\n cmovgl %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("sxtb %w0,%w1\n cmp %w0,0\n csetm %w0,gt" : "=r"(crypto_int8_z) : "r"(crypto_int8_x) : "cc");
return crypto_int8_z;
#else
crypto_int8 crypto_int8_z = -crypto_int8_x;
crypto_int8_z ^= crypto_int8_x & crypto_int8_z;
return crypto_int8_negative_mask(crypto_int8_z);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_positive_01(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n testb %b2,%b2\n cmovgl %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("sxtb %w0,%w1\n cmp %w0,0\n cset %w0,gt" : "=r"(crypto_int8_z) : "r"(crypto_int8_x) : "cc");
return crypto_int8_z;
#else
crypto_int8 crypto_int8_z = -crypto_int8_x;
crypto_int8_z ^= crypto_int8_x & crypto_int8_z;
return crypto_int8_unsigned_topbit_01(crypto_int8_z);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_zero_mask(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testb %b2,%b2\n cmovel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("tst %w1,255\n csetm %w0,eq" : "=r"(crypto_int8_z) : "r"(crypto_int8_x) : "cc");
return crypto_int8_z;
#else
return ~crypto_int8_nonzero_mask(crypto_int8_x);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_zero_01(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n testb %b2,%b2\n cmovel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("tst %w1,255\n cset %w0,eq" : "=r"(crypto_int8_z) : "r"(crypto_int8_x) : "cc");
return crypto_int8_z;
#else
return 1-crypto_int8_nonzero_01(crypto_int8_x);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_unequal_mask(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovnel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n csetm %w0,ne" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
return crypto_int8_nonzero_mask(crypto_int8_x ^ crypto_int8_y);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_unequal_01(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovnel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n cset %w0,ne" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
return crypto_int8_nonzero_01(crypto_int8_x ^ crypto_int8_y);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_equal_mask(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n csetm %w0,eq" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
return ~crypto_int8_unequal_mask(crypto_int8_x,crypto_int8_y);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_equal_01(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n cset %w0,eq" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
return 1-crypto_int8_unequal_01(crypto_int8_x,crypto_int8_y);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_min(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y;
__asm__ ("cmpb %b1,%b0\n cmovgl %1,%0" : "+q"(crypto_int8_x32) : "q"(crypto_int8_y32) : "cc");
crypto_int8_x = crypto_int8_x32;
return crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxtb %w0,%w0\n cmp %w0,%w1,sxtb\n csel %w0,%w0,%w1,lt" : "+&r"(crypto_int8_x) : "r"(crypto_int8_y) : "cc");
return crypto_int8_x;
#else
crypto_int8 crypto_int8_r = crypto_int8_y ^ crypto_int8_x;
crypto_int8 crypto_int8_z = crypto_int8_y - crypto_int8_x;
crypto_int8_z ^= crypto_int8_r & (crypto_int8_z ^ crypto_int8_y);
crypto_int8_z = crypto_int8_negative_mask(crypto_int8_z);
crypto_int8_z &= crypto_int8_r;
return crypto_int8_x ^ crypto_int8_z;
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_max(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y;
__asm__ ("cmpb %b1,%b0\n cmovll %1,%0" : "+q"(crypto_int8_x32) : "q"(crypto_int8_y32) : "cc");
crypto_int8_x = crypto_int8_x32;
return crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("sxtb %w0,%w0\n cmp %w0,%w1,sxtb\n csel %w0,%w1,%w0,lt" : "+&r"(crypto_int8_x) : "r"(crypto_int8_y) : "cc");
return crypto_int8_x;
#else
crypto_int8 crypto_int8_r = crypto_int8_y ^ crypto_int8_x;
crypto_int8 crypto_int8_z = crypto_int8_y - crypto_int8_x;
crypto_int8_z ^= crypto_int8_r & (crypto_int8_z ^ crypto_int8_y);
crypto_int8_z = crypto_int8_negative_mask(crypto_int8_z);
crypto_int8_z &= crypto_int8_r;
return crypto_int8_y ^ crypto_int8_z;
#endif
}
__attribute__((unused))
static inline
void crypto_int8_minmax(crypto_int8 *crypto_int8_p,crypto_int8 *crypto_int8_q) {
crypto_int8 crypto_int8_x = *crypto_int8_p;
crypto_int8 crypto_int8_y = *crypto_int8_q;
#if defined(__GNUC__) && defined(__x86_64__)
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_z32;
__asm__ ("cmpb %b2,%b1\n movl %1,%0\n cmovgl %2,%1\n cmovgl %0,%2" : "=&r"(crypto_int8_z32), "+&q"(crypto_int8_x32), "+q"(crypto_int8_y32) : : "cc");
crypto_int8_x = crypto_int8_x32; crypto_int8_y = crypto_int8_y32;
*crypto_int8_p = crypto_int8_x;
*crypto_int8_q = crypto_int8_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_r, crypto_int8_s;
__asm__ ("sxtb %w0,%w0\n cmp %w0,%w3,sxtb\n csel %w1,%w0,%w3,lt\n csel %w2,%w3,%w0,lt" : "+&r"(crypto_int8_x), "=&r"(crypto_int8_r), "=r"(crypto_int8_s) : "r"(crypto_int8_y) : "cc");
*crypto_int8_p = crypto_int8_r;
*crypto_int8_q = crypto_int8_s;
#else
crypto_int8 crypto_int8_r = crypto_int8_y ^ crypto_int8_x;
crypto_int8 crypto_int8_z = crypto_int8_y - crypto_int8_x;
crypto_int8_z ^= crypto_int8_r & (crypto_int8_z ^ crypto_int8_y);
crypto_int8_z = crypto_int8_negative_mask(crypto_int8_z);
crypto_int8_z &= crypto_int8_r;
crypto_int8_x ^= crypto_int8_z;
crypto_int8_y ^= crypto_int8_z;
*crypto_int8_p = crypto_int8_x;
*crypto_int8_q = crypto_int8_y;
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_smaller_mask(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovll %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("sxtb %w0,%w1\n cmp %w0,%w2,sxtb\n csetm %w0,lt" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
crypto_int8 crypto_int8_r = crypto_int8_x ^ crypto_int8_y;
crypto_int8 crypto_int8_z = crypto_int8_x - crypto_int8_y;
crypto_int8_z ^= crypto_int8_r & (crypto_int8_z ^ crypto_int8_x);
return crypto_int8_negative_mask(crypto_int8_z);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_smaller_01(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovll %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("sxtb %w0,%w1\n cmp %w0,%w2,sxtb\n cset %w0,lt" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
crypto_int8 crypto_int8_r = crypto_int8_x ^ crypto_int8_y;
crypto_int8 crypto_int8_z = crypto_int8_x - crypto_int8_y;
crypto_int8_z ^= crypto_int8_r & (crypto_int8_z ^ crypto_int8_x);
return crypto_int8_unsigned_topbit_01(crypto_int8_z);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_leq_mask(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovlel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("sxtb %w0,%w1\n cmp %w0,%w2,sxtb\n csetm %w0,le" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
return ~crypto_int8_smaller_mask(crypto_int8_y,crypto_int8_x);
#endif
}
__attribute__((unused))
static inline
crypto_int8 crypto_int8_leq_01(crypto_int8 crypto_int8_x,crypto_int8 crypto_int8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_int8 crypto_int8_z;
int32_t crypto_int8_x32 = crypto_int8_x,crypto_int8_y32 = crypto_int8_y,crypto_int8_q32,crypto_int8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovlel %1,%0" : "=&r"(crypto_int8_z32), "=&r"(crypto_int8_q32) : "q"(crypto_int8_x32), "q"(crypto_int8_y32) : "cc");
crypto_int8_z = crypto_int8_z32;
return crypto_int8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_int8 crypto_int8_z;
__asm__ ("sxtb %w0,%w1\n cmp %w0,%w2,sxtb\n cset %w0,le" : "=&r"(crypto_int8_z) : "r"(crypto_int8_x), "r"(crypto_int8_y) : "cc");
return crypto_int8_z;
#else
return 1-crypto_int8_smaller_01(crypto_int8_y,crypto_int8_x);
#endif
}
__attribute__((unused))
static inline
int crypto_int8_ones_num(crypto_int8 crypto_int8_x) {
crypto_int8_unsigned crypto_int8_y = crypto_int8_x;
const crypto_int8 C0 = 0x55;
const crypto_int8 C1 = 0x33;
const crypto_int8 C2 = 0x0f;
crypto_int8_y -= ((crypto_int8_y >> 1) & C0);
crypto_int8_y = (crypto_int8_y & C1) + ((crypto_int8_y >> 2) & C1);
crypto_int8_y = (crypto_int8_y + (crypto_int8_y >> 4)) & C2;
return crypto_int8_y;
}
__attribute__((unused))
static inline
int crypto_int8_bottomzeros_num(crypto_int8 crypto_int8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
int32_t fallback = 8;
int32_t crypto_int8_x32 = crypto_int8_x;
__asm__ ("bsfl %0,%0\n cmovel %1,%0" : "+&r"(crypto_int8_x32) : "r"(fallback) : "cc");
crypto_int8_x = crypto_int8_x32;
return crypto_int8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_int8_y;
__asm__ ("orr %w0,%w1,-256\n rbit %w0,%w0\n clz %w0,%w0" : "=r"(crypto_int8_y) : "r"(crypto_int8_x) : );
return crypto_int8_y;
#else
crypto_int8 crypto_int8_y = crypto_int8_x ^ (crypto_int8_x-1);
crypto_int8_y = ((crypto_int8) crypto_int8_y) >> 1;
crypto_int8_y &= ~(crypto_int8_x & (((crypto_int8) 1) << (8-1)));
return crypto_int8_ones_num(crypto_int8_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_intN.h 0000664 0000000 0000000 00000140740 14745512304 0020205 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_intN_h
#define crypto_intN_h
#include
#define crypto_intN intN_t
#define crypto_intN_unsigned uintN_t
#define crypto_intN_optblocker namespace_intN_optblocker
extern volatile crypto_intN crypto_intN_optblocker;
__attribute__((unused))
static inline
crypto_intN crypto_intN_load(const unsigned char *crypto_intN_s) {
crypto_intN crypto_intN_z = 0;
int crypto_intN_k;
for (crypto_intN_k = 0;crypto_intN_k < N;crypto_intN_k += 8)
crypto_intN_z |= ((crypto_intN) (*crypto_intN_s++)) << crypto_intN_k;
return crypto_intN_z;
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_load_bigendian(const unsigned char *crypto_intN_s) {
crypto_intN crypto_intN_z = 0;
int crypto_intN_k;
for (crypto_intN_k = N - 8;crypto_intN_k >= 0;crypto_intN_k -= 8)
crypto_intN_z |= ((crypto_intN) (*crypto_intN_s++)) << crypto_intN_k;
return crypto_intN_z;
}
__attribute__((unused))
static inline
void crypto_intN_store(unsigned char *crypto_intN_s,crypto_intN crypto_intN_x) {
int crypto_intN_k;
for (crypto_intN_k = 0;crypto_intN_k < N;crypto_intN_k += 8)
*crypto_intN_s++ = crypto_intN_x >> crypto_intN_k;
}
__attribute__((unused))
static inline
void crypto_intN_store_bigendian(unsigned char *crypto_intN_s,crypto_intN crypto_intN_x) {
int crypto_intN_k;
for (crypto_intN_k = N - 8;crypto_intN_k >= 0;crypto_intN_k -= 8)
*crypto_intN_s++ = crypto_intN_x >> crypto_intN_k;
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_negative_mask(crypto_intN crypto_intN_x) {
#if amd64
8: readasm("amd64; int8 crypto_intN_x; crypto_intN_x signed>>= 7");
16: readasm("amd64; int16 crypto_intN_x; crypto_intN_x signed>>= 15");
32: readasm("amd64; int32 crypto_intN_x; crypto_intN_x signed>>= 31");
64: readasm("amd64; int64 crypto_intN_x; crypto_intN_x signed>>= 63");
return crypto_intN_x;
#elif arm64
crypto_intN crypto_intN_y;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_y = -(1 & (crypto_intN_x unsigned>> 7))");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_y = -(1 & (crypto_intN_x unsigned>> 15))");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_y = crypto_intN_x signed>> 31");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_y = crypto_intN_x signed>> 63");
return crypto_intN_y;
#else
crypto_intN_x >>= N-6;
crypto_intN_x += crypto_intN_optblocker;
crypto_intN_x >>= 5;
return crypto_intN_x;
#endif
}
__attribute__((unused))
static inline
crypto_intN_unsigned crypto_intN_unsigned_topbit_01(crypto_intN_unsigned crypto_intN_x) {
#if amd64
8: readasm("amd64; int8 crypto_intN_x; crypto_intN_x unsigned>>= 7");
16: readasm("amd64; int16 crypto_intN_x; crypto_intN_x unsigned>>= 15");
32: readasm("amd64; int32 crypto_intN_x; crypto_intN_x unsigned>>= 31");
64: readasm("amd64; int64 crypto_intN_x; crypto_intN_x unsigned>>= 63");
return crypto_intN_x;
#elif arm64
crypto_intN crypto_intN_y;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_y = 1 & (crypto_intN_x unsigned>> 7)");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_y = 1 & (crypto_intN_x unsigned>> 15)");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_y = crypto_intN_x unsigned>> 31");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_y = crypto_intN_x unsigned>> 63");
return crypto_intN_y;
#else
crypto_intN_x >>= N-6;
crypto_intN_x += crypto_intN_optblocker;
crypto_intN_x >>= 5;
return crypto_intN_x;
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_negative_01(crypto_intN crypto_intN_x) {
return crypto_intN_unsigned_topbit_01(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_topbit_mask(crypto_intN crypto_intN_x) {
return crypto_intN_negative_mask(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_topbit_01(crypto_intN crypto_intN_x) {
return crypto_intN_unsigned_topbit_01(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_bottombit_mask(crypto_intN crypto_intN_x) {
#if amd64
8: readasm("amd64; int8 crypto_intN_x; crypto_intN_x &= 1");
16: readasm("amd64; int16 crypto_intN_x; crypto_intN_x &= 1");
32: readasm("amd64; int32 crypto_intN_x; crypto_intN_x &= 1");
64: readasm("amd64; int64 crypto_intN_x; crypto_intN_x &= 1");
return -crypto_intN_x;
#elif arm64
crypto_intN crypto_intN_y;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_y = -(1 & (crypto_intN_x unsigned>> 0))");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_y = -(1 & (crypto_intN_x unsigned>> 0))");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_y = -(1 & (crypto_intN_x unsigned>> 0))");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_y = -(1 & (crypto_intN_x unsigned>> 0))");
return crypto_intN_y;
#else
crypto_intN_x &= 1 + crypto_intN_optblocker;
return -crypto_intN_x;
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_bottombit_01(crypto_intN crypto_intN_x) {
#if amd64
8: readasm("amd64; int8 crypto_intN_x; crypto_intN_x &= 1");
16: readasm("amd64; int16 crypto_intN_x; crypto_intN_x &= 1");
32: readasm("amd64; int32 crypto_intN_x; crypto_intN_x &= 1");
64: readasm("amd64; int64 crypto_intN_x; crypto_intN_x &= 1");
return crypto_intN_x;
#elif arm64
crypto_intN crypto_intN_y;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_y = 1 & (crypto_intN_x unsigned>> 0)");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_y = 1 & (crypto_intN_x unsigned>> 0)");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_y = 1 & (crypto_intN_x unsigned>> 0)");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_y = 1 & (crypto_intN_x unsigned>> 0)");
return crypto_intN_y;
#else
crypto_intN_x &= 1 + crypto_intN_optblocker;
return crypto_intN_x;
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_bitinrangepublicpos_mask(crypto_intN crypto_intN_x,crypto_intN crypto_intN_s) {
#if amd64
8: readasm("amd64; int8 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
16: readasm("amd64; int16 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
32: readasm("amd64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
64: readasm("amd64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
#elif arm64
8: readasm("arm64; int8 crypto_intN_x crypto_intN_s; crypto_intN_x = (int8) crypto_intN_x; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_s; crypto_intN_x = (int16) crypto_intN_x; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
#else
crypto_intN_x >>= crypto_intN_s ^ crypto_intN_optblocker;
#endif
return crypto_intN_bottombit_mask(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_bitinrangepublicpos_01(crypto_intN crypto_intN_x,crypto_intN crypto_intN_s) {
#if amd64
8: readasm("amd64; int8 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
16: readasm("amd64; int16 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
32: readasm("amd64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
64: readasm("amd64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
#elif arm64
8: readasm("arm64; int8 crypto_intN_x crypto_intN_s; crypto_intN_x = (int8) crypto_intN_x; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_s; crypto_intN_x = (int16) crypto_intN_x; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
#else
crypto_intN_x >>= crypto_intN_s ^ crypto_intN_optblocker;
#endif
return crypto_intN_bottombit_01(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_shlmod(crypto_intN crypto_intN_x,crypto_intN crypto_intN_s) {
#if amd64
8: crypto_intN_s &= 7;
8: readasm("amd64; int8 crypto_intN_x crypto_intN_s; crypto_intN_x <<= crypto_intN_s");
16: crypto_intN_s &= 15;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_s; crypto_intN_x <<= crypto_intN_s");
32: readasm("amd64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x <<= crypto_intN_s");
64: readasm("amd64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x <<= crypto_intN_s");
#elif arm64
8: readasm("arm64; int8 crypto_intN_x crypto_intN_s; crypto_intN_s = crypto_intN_s & 7; crypto_intN_x = (uint8) crypto_intN_x; crypto_intN_x = crypto_intN_x << crypto_intN_s");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_s; crypto_intN_s = crypto_intN_s & 15; crypto_intN_x = (uint16) crypto_intN_x; crypto_intN_x = crypto_intN_x << crypto_intN_s");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x << crypto_intN_s");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x << crypto_intN_s");
#else
int crypto_intN_k, crypto_intN_l;
for (crypto_intN_l = 0,crypto_intN_k = 1;crypto_intN_k < N;++crypto_intN_l,crypto_intN_k *= 2)
crypto_intN_x ^= (crypto_intN_x ^ (crypto_intN_x << crypto_intN_k)) & crypto_intN_bitinrangepublicpos_mask(crypto_intN_s,crypto_intN_l);
#endif
return crypto_intN_x;
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_shrmod(crypto_intN crypto_intN_x,crypto_intN crypto_intN_s) {
#if amd64
8: crypto_intN_s &= 7;
8: readasm("amd64; int8 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
16: crypto_intN_s &= 15;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
32: readasm("amd64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
64: readasm("amd64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x signed>>= crypto_intN_s");
#elif arm64
8: readasm("arm64; int8 crypto_intN_x crypto_intN_s; crypto_intN_s = crypto_intN_s & 7; crypto_intN_x = (int8) crypto_intN_x; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_s; crypto_intN_s = crypto_intN_s & 15; crypto_intN_x = (int16) crypto_intN_x; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_s; crypto_intN_x = crypto_intN_x signed>> crypto_intN_s");
#else
int crypto_intN_k, crypto_intN_l;
for (crypto_intN_l = 0,crypto_intN_k = 1;crypto_intN_k < N;++crypto_intN_l,crypto_intN_k *= 2)
crypto_intN_x ^= (crypto_intN_x ^ (crypto_intN_x >> crypto_intN_k)) & crypto_intN_bitinrangepublicpos_mask(crypto_intN_s,crypto_intN_l);
#endif
return crypto_intN_x;
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_bitmod_mask(crypto_intN crypto_intN_x,crypto_intN crypto_intN_s) {
crypto_intN_x = crypto_intN_shrmod(crypto_intN_x,crypto_intN_s);
return crypto_intN_bottombit_mask(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_bitmod_01(crypto_intN crypto_intN_x,crypto_intN crypto_intN_s) {
crypto_intN_x = crypto_intN_shrmod(crypto_intN_x,crypto_intN_s);
return crypto_intN_bottombit_01(crypto_intN_x);
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_nonzero_mask(crypto_intN crypto_intN_x) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 & (int8) crypto_intN_x32; crypto_intN_z32 = crypto_intN_q32 if !=");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if !=");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if !=");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if !=");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_z; crypto_intN_x & 255; crypto_intN_z = -1 if != else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_z; crypto_intN_x & 65535; crypto_intN_z = -1 if != else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = -1 if != else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = -1 if != else 0");
return crypto_intN_z;
#else
crypto_intN_x |= -crypto_intN_x;
return crypto_intN_negative_mask(crypto_intN_x);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_nonzero_01(crypto_intN crypto_intN_x) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 & (int8) crypto_intN_x32; crypto_intN_z32 = crypto_intN_q32 if !=");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if !=");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if !=");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if !=");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_z; crypto_intN_x & 255; crypto_intN_z = 1 if != else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_z; crypto_intN_x & 65535; crypto_intN_z = 1 if != else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = 1 if != else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = 1 if != else 0");
return crypto_intN_z;
#else
crypto_intN_x |= -crypto_intN_x;
return crypto_intN_unsigned_topbit_01(crypto_intN_x);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_positive_mask(crypto_intN crypto_intN_x) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 & (int8) crypto_intN_x32; crypto_intN_z32 = crypto_intN_q32 if signed>");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if signed>");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if signed>");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if signed>");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_z; crypto_intN_z = (int8) crypto_intN_x; crypto_intN_z - 0; crypto_intN_z = -1 if signed> else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_z; crypto_intN_z = (int16) crypto_intN_x; crypto_intN_z - 0; crypto_intN_z = -1 if signed> else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = -1 if signed> else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = -1 if signed> else 0");
return crypto_intN_z;
#else
crypto_intN crypto_intN_z = -crypto_intN_x;
crypto_intN_z ^= crypto_intN_x & crypto_intN_z;
return crypto_intN_negative_mask(crypto_intN_z);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_positive_01(crypto_intN crypto_intN_x) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 & (int8) crypto_intN_x32; crypto_intN_z32 = crypto_intN_q32 if signed>");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if signed>");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if signed>");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if signed>");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_z; crypto_intN_z = (int8) crypto_intN_x; crypto_intN_z - 0; crypto_intN_z = 1 if signed> else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_z; crypto_intN_z = (int16) crypto_intN_x; crypto_intN_z - 0; crypto_intN_z = 1 if signed> else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = 1 if signed> else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = 1 if signed> else 0");
return crypto_intN_z;
#else
crypto_intN crypto_intN_z = -crypto_intN_x;
crypto_intN_z ^= crypto_intN_x & crypto_intN_z;
return crypto_intN_unsigned_topbit_01(crypto_intN_z);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_zero_mask(crypto_intN crypto_intN_x) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 & (int8) crypto_intN_x32; crypto_intN_z32 = crypto_intN_q32 if =");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if =");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if =");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if =");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_z; crypto_intN_x & 255; crypto_intN_z = -1 if = else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_z; crypto_intN_x & 65535; crypto_intN_z = -1 if = else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = -1 if = else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = -1 if = else 0");
return crypto_intN_z;
#else
return ~crypto_intN_nonzero_mask(crypto_intN_x);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_zero_01(crypto_intN crypto_intN_x) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 & (int8) crypto_intN_x32; crypto_intN_z32 = crypto_intN_q32 if =");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if =");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if =");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x & crypto_intN_x; crypto_intN_z = crypto_intN_q if =");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_z; crypto_intN_x & 255; crypto_intN_z = 1 if = else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_z; crypto_intN_x & 65535; crypto_intN_z = 1 if = else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = 1 if = else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_z; crypto_intN_x - 0; crypto_intN_z = 1 if = else 0");
return crypto_intN_z;
#else
return 1-crypto_intN_nonzero_01(crypto_intN_x);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_unequal_mask(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if !=");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if !=");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if !=");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if !=");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint8) crypto_intN_x; crypto_intN_z - (uint8) crypto_intN_y; crypto_intN_z = -1 if != else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint16) crypto_intN_x; crypto_intN_z - (uint16) crypto_intN_y; crypto_intN_z = -1 if != else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if != else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if != else 0");
return crypto_intN_z;
#else
return crypto_intN_nonzero_mask(crypto_intN_x ^ crypto_intN_y);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_unequal_01(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if !=");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if !=");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if !=");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if !=");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint8) crypto_intN_x; crypto_intN_z - (uint8) crypto_intN_y; crypto_intN_z = 1 if != else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint16) crypto_intN_x; crypto_intN_z - (uint16) crypto_intN_y; crypto_intN_z = 1 if != else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if != else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if != else 0");
return crypto_intN_z;
#else
return crypto_intN_nonzero_01(crypto_intN_x ^ crypto_intN_y);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_equal_mask(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if =");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if =");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if =");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if =");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint8) crypto_intN_x; crypto_intN_z - (uint8) crypto_intN_y; crypto_intN_z = -1 if = else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint16) crypto_intN_x; crypto_intN_z - (uint16) crypto_intN_y; crypto_intN_z = -1 if = else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if = else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if = else 0");
return crypto_intN_z;
#else
return ~crypto_intN_unequal_mask(crypto_intN_x,crypto_intN_y);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_equal_01(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if =");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if =");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if =");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if =");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint8) crypto_intN_x; crypto_intN_z - (uint8) crypto_intN_y; crypto_intN_z = 1 if = else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (uint16) crypto_intN_x; crypto_intN_z - (uint16) crypto_intN_y; crypto_intN_z = 1 if = else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if = else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if = else 0");
return crypto_intN_z;
#else
return 1-crypto_intN_unequal_01(crypto_intN_x,crypto_intN_y);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_min(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_y32; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_x32 = crypto_intN_y32 if signed>");
8: crypto_intN_x = crypto_intN_x32;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed>");
32: readasm("amd64; int32 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed>");
64: readasm("amd64; int64 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed>");
return crypto_intN_x;
#elif arm64
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_x = (int8) crypto_intN_x; crypto_intN_x - (int8) crypto_intN_y; crypto_intN_x = crypto_intN_x if signed< else crypto_intN_y");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_x = (int16) crypto_intN_x; crypto_intN_x - (int16) crypto_intN_y; crypto_intN_x = crypto_intN_x if signed< else crypto_intN_y");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_x if signed< else crypto_intN_y");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_x if signed< else crypto_intN_y");
return crypto_intN_x;
#else
crypto_intN crypto_intN_r = crypto_intN_y ^ crypto_intN_x;
crypto_intN crypto_intN_z = crypto_intN_y - crypto_intN_x;
crypto_intN_z ^= crypto_intN_r & (crypto_intN_z ^ crypto_intN_y);
crypto_intN_z = crypto_intN_negative_mask(crypto_intN_z);
crypto_intN_z &= crypto_intN_r;
return crypto_intN_x ^ crypto_intN_z;
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_max(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_y32; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_x32 = crypto_intN_y32 if signed<");
8: crypto_intN_x = crypto_intN_x32;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed<");
32: readasm("amd64; int32 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed<");
64: readasm("amd64; int64 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed<");
return crypto_intN_x;
#elif arm64
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_x = (int8) crypto_intN_x; crypto_intN_x - (int8) crypto_intN_y; crypto_intN_x = crypto_intN_y if signed< else crypto_intN_x");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_x = (int16) crypto_intN_x; crypto_intN_x - (int16) crypto_intN_y; crypto_intN_x = crypto_intN_y if signed< else crypto_intN_x");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed< else crypto_intN_x");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_x - crypto_intN_y; crypto_intN_x = crypto_intN_y if signed< else crypto_intN_x");
return crypto_intN_x;
#else
crypto_intN crypto_intN_r = crypto_intN_y ^ crypto_intN_x;
crypto_intN crypto_intN_z = crypto_intN_y - crypto_intN_x;
crypto_intN_z ^= crypto_intN_r & (crypto_intN_z ^ crypto_intN_y);
crypto_intN_z = crypto_intN_negative_mask(crypto_intN_z);
crypto_intN_z &= crypto_intN_r;
return crypto_intN_y ^ crypto_intN_z;
#endif
}
__attribute__((unused))
static inline
void crypto_intN_minmax(crypto_intN *crypto_intN_p,crypto_intN *crypto_intN_q) {
crypto_intN crypto_intN_x = *crypto_intN_p;
crypto_intN crypto_intN_y = *crypto_intN_q;
#if amd64
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_y32 crypto_intN_z32; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_x32; crypto_intN_x32 = crypto_intN_y32 if signed>; crypto_intN_y32 = crypto_intN_z32 if signed>");
8: crypto_intN_x = crypto_intN_x32; crypto_intN_y = crypto_intN_y32;
16: crypto_intN crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_x; crypto_intN_x = crypto_intN_y if signed>; crypto_intN_y = crypto_intN_z if signed>");
32: crypto_intN crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_x; crypto_intN_x = crypto_intN_y if signed>; crypto_intN_y = crypto_intN_z if signed>");
64: crypto_intN crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_x; crypto_intN_x = crypto_intN_y if signed>; crypto_intN_y = crypto_intN_z if signed>");
*crypto_intN_p = crypto_intN_x;
*crypto_intN_q = crypto_intN_y;
#elif arm64
crypto_intN crypto_intN_r, crypto_intN_s;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_r crypto_intN_s; crypto_intN_x = (int8) crypto_intN_x; crypto_intN_x - (int8) crypto_intN_y; crypto_intN_r = crypto_intN_x if signed< else crypto_intN_y; crypto_intN_s = crypto_intN_y if signed< else crypto_intN_x");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_r crypto_intN_s; crypto_intN_x = (int16) crypto_intN_x; crypto_intN_x - (int16) crypto_intN_y; crypto_intN_r = crypto_intN_x if signed< else crypto_intN_y; crypto_intN_s = crypto_intN_y if signed< else crypto_intN_x");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_r crypto_intN_s; crypto_intN_x - crypto_intN_y; crypto_intN_r = crypto_intN_x if signed< else crypto_intN_y; crypto_intN_s = crypto_intN_y if signed< else crypto_intN_x");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_r crypto_intN_s; crypto_intN_x - crypto_intN_y; crypto_intN_r = crypto_intN_x if signed< else crypto_intN_y; crypto_intN_s = crypto_intN_y if signed< else crypto_intN_x");
*crypto_intN_p = crypto_intN_r;
*crypto_intN_q = crypto_intN_s;
#else
crypto_intN crypto_intN_r = crypto_intN_y ^ crypto_intN_x;
crypto_intN crypto_intN_z = crypto_intN_y - crypto_intN_x;
crypto_intN_z ^= crypto_intN_r & (crypto_intN_z ^ crypto_intN_y);
crypto_intN_z = crypto_intN_negative_mask(crypto_intN_z);
crypto_intN_z &= crypto_intN_r;
crypto_intN_x ^= crypto_intN_z;
crypto_intN_y ^= crypto_intN_z;
*crypto_intN_p = crypto_intN_x;
*crypto_intN_q = crypto_intN_y;
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_smaller_mask(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if signed<");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int8) crypto_intN_x; crypto_intN_z - (int8) crypto_intN_y; crypto_intN_z = -1 if signed< else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int16) crypto_intN_x; crypto_intN_z - (int16) crypto_intN_y; crypto_intN_z = -1 if signed< else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if signed< else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if signed< else 0");
return crypto_intN_z;
#else
crypto_intN crypto_intN_r = crypto_intN_x ^ crypto_intN_y;
crypto_intN crypto_intN_z = crypto_intN_x - crypto_intN_y;
crypto_intN_z ^= crypto_intN_r & (crypto_intN_z ^ crypto_intN_x);
return crypto_intN_negative_mask(crypto_intN_z);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_smaller_01(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if signed<");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int8) crypto_intN_x; crypto_intN_z - (int8) crypto_intN_y; crypto_intN_z = 1 if signed< else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int16) crypto_intN_x; crypto_intN_z - (int16) crypto_intN_y; crypto_intN_z = 1 if signed< else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if signed< else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if signed< else 0");
return crypto_intN_z;
#else
crypto_intN crypto_intN_r = crypto_intN_x ^ crypto_intN_y;
crypto_intN crypto_intN_z = crypto_intN_x - crypto_intN_y;
crypto_intN_z ^= crypto_intN_r & (crypto_intN_z ^ crypto_intN_x);
return crypto_intN_unsigned_topbit_01(crypto_intN_z);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_leq_mask(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = -1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if signed<=");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<=");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<=");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = -1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<=");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int8) crypto_intN_x; crypto_intN_z - (int8) crypto_intN_y; crypto_intN_z = -1 if signed<= else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int16) crypto_intN_x; crypto_intN_z - (int16) crypto_intN_y; crypto_intN_z = -1 if signed<= else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if signed<= else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = -1 if signed<= else 0");
return crypto_intN_z;
#else
return ~crypto_intN_smaller_mask(crypto_intN_y,crypto_intN_x);
#endif
}
__attribute__((unused))
static inline
crypto_intN crypto_intN_leq_01(crypto_intN crypto_intN_x,crypto_intN crypto_intN_y) {
#if amd64
8: crypto_intN crypto_intN_z;
8: int32_t crypto_intN_x32 = crypto_intN_x,crypto_intN_y32 = crypto_intN_y,crypto_intN_q32,crypto_intN_z32;
8: readasm("amd64; int32 crypto_intN_x32 crypto_intN_q32 crypto_intN_y32 crypto_intN_z32; crypto_intN_z32 = 0; crypto_intN_q32 = 1; crypto_intN_x32 - (int8) crypto_intN_y32; crypto_intN_z32 = crypto_intN_q32 if signed<=");
8: crypto_intN_z = crypto_intN_z32;
16: crypto_intN crypto_intN_q,crypto_intN_z;
16: readasm("amd64; int16 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<=");
32: crypto_intN crypto_intN_q,crypto_intN_z;
32: readasm("amd64; int32 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<=");
64: crypto_intN crypto_intN_q,crypto_intN_z;
64: readasm("amd64; int64 crypto_intN_x crypto_intN_q crypto_intN_y crypto_intN_z; crypto_intN_z = 0; crypto_intN_q = 1; crypto_intN_x - crypto_intN_y; crypto_intN_z = crypto_intN_q if signed<=");
return crypto_intN_z;
#elif arm64
crypto_intN crypto_intN_z;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int8) crypto_intN_x; crypto_intN_z - (int8) crypto_intN_y; crypto_intN_z = 1 if signed<= else 0");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_z = (int16) crypto_intN_x; crypto_intN_z - (int16) crypto_intN_y; crypto_intN_z = 1 if signed<= else 0");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if signed<= else 0");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y crypto_intN_z; crypto_intN_x - crypto_intN_y; crypto_intN_z = 1 if signed<= else 0");
return crypto_intN_z;
#else
return 1-crypto_intN_smaller_01(crypto_intN_y,crypto_intN_x);
#endif
}
__attribute__((unused))
static inline
int crypto_intN_ones_num(crypto_intN crypto_intN_x) {
crypto_intN_unsigned crypto_intN_y = crypto_intN_x;
8: const crypto_intN C0 = 0x55;
16: const crypto_intN C0 = 0x5555;
32: const crypto_intN C0 = 0x55555555;
64: const crypto_intN C0 = 0x5555555555555555;
8: const crypto_intN C1 = 0x33;
16: const crypto_intN C1 = 0x3333;
32: const crypto_intN C1 = 0x33333333;
64: const crypto_intN C1 = 0x3333333333333333;
8: const crypto_intN C2 = 0x0f;
16: const crypto_intN C2 = 0x0f0f;
32: const crypto_intN C2 = 0x0f0f0f0f;
64: const crypto_intN C2 = 0x0f0f0f0f0f0f0f0f;
crypto_intN_y -= ((crypto_intN_y >> 1) & C0);
crypto_intN_y = (crypto_intN_y & C1) + ((crypto_intN_y >> 2) & C1);
crypto_intN_y = (crypto_intN_y + (crypto_intN_y >> 4)) & C2;
16: crypto_intN_y = (crypto_intN_y + (crypto_intN_y >> 8)) & 0xff;
32: crypto_intN_y += crypto_intN_y >> 8;
32: crypto_intN_y = (crypto_intN_y + (crypto_intN_y >> 16)) & 0xff;
64: crypto_intN_y += crypto_intN_y >> 8;
64: crypto_intN_y += crypto_intN_y >> 16;
64: crypto_intN_y = (crypto_intN_y + (crypto_intN_y >> 32)) & 0xff;
return crypto_intN_y;
}
__attribute__((unused))
static inline
int crypto_intN_bottomzeros_num(crypto_intN crypto_intN_x) {
#if amd64
8: int32_t fallback = N;
8: int32_t crypto_intN_x32 = crypto_intN_x;
8: readasm("amd64; int32 crypto_intN_x32 fallback; crypto_intN_x32 = numbottomzeros_tricky crypto_intN_x32; crypto_intN_x32 = fallback if =");
8: crypto_intN_x = crypto_intN_x32;
16: crypto_intN fallback = N;
16: readasm("amd64; int16 crypto_intN_x fallback; crypto_intN_x = numbottomzeros_tricky crypto_intN_x; crypto_intN_x = fallback if =");
32: crypto_intN fallback = N;
32: readasm("amd64; int32 crypto_intN_x fallback; crypto_intN_x = numbottomzeros_tricky crypto_intN_x; crypto_intN_x = fallback if =");
64: crypto_intN fallback = N;
64: readasm("amd64; int64 crypto_intN_x fallback; crypto_intN_x = numbottomzeros_tricky crypto_intN_x; crypto_intN_x = fallback if =");
return crypto_intN_x;
#elif arm64
int64_t crypto_intN_y;
8: readasm("arm64; int8 crypto_intN_x crypto_intN_y; crypto_intN_y = crypto_intN_x | -256; crypto_intN_y = bitrev32 crypto_intN_y; crypto_intN_y = numbottomzeros crypto_intN_y");
16: readasm("arm64; int16 crypto_intN_x crypto_intN_y; crypto_intN_y = crypto_intN_x | -65536; crypto_intN_y = bitrev32 crypto_intN_y; crypto_intN_y = numbottomzeros crypto_intN_y");
32: readasm("arm64; int32 crypto_intN_x crypto_intN_y; crypto_intN_y = bitrev32 crypto_intN_x; crypto_intN_y = numbottomzeros crypto_intN_y");
64: readasm("arm64; int64 crypto_intN_x crypto_intN_y; crypto_intN_y = bitrev64 crypto_intN_x; crypto_intN_y = numbottomzeros crypto_intN_y");
return crypto_intN_y;
#else
crypto_intN crypto_intN_y = crypto_intN_x ^ (crypto_intN_x-1);
crypto_intN_y = ((crypto_intN) crypto_intN_y) >> 1;
crypto_intN_y &= ~(crypto_intN_x & (((crypto_intN) 1) << (N-1)));
return crypto_intN_ones_num(crypto_intN_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_uint16.h 0000664 0000000 0000000 00000051133 14745512304 0020420 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_uint16_h
#define crypto_uint16_h
#include
#define crypto_uint16 uint16_t
#define crypto_uint16_signed int16_t
#define crypto_uint16_signed_optblocker tinyssh_uint16_signed_optblocker
extern volatile crypto_uint16_signed crypto_uint16_signed_optblocker;
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_load(const unsigned char *crypto_uint16_s) {
crypto_uint16 crypto_uint16_z = 0;
crypto_uint16_z |= ((crypto_uint16) (*crypto_uint16_s++)) << 0;
crypto_uint16_z |= ((crypto_uint16) (*crypto_uint16_s++)) << 8;
return crypto_uint16_z;
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_load_bigendian(const unsigned char *crypto_uint16_s) {
crypto_uint16 crypto_uint16_z = 0;
crypto_uint16_z |= ((crypto_uint16) (*crypto_uint16_s++)) << 8;
crypto_uint16_z |= ((crypto_uint16) (*crypto_uint16_s++)) << 0;
return crypto_uint16_z;
}
__attribute__((unused))
static inline
void crypto_uint16_store(unsigned char *crypto_uint16_s,crypto_uint16 crypto_uint16_x) {
*crypto_uint16_s++ = crypto_uint16_x >> 0;
*crypto_uint16_s++ = crypto_uint16_x >> 8;
}
__attribute__((unused))
static inline
void crypto_uint16_store_bigendian(unsigned char *crypto_uint16_s,crypto_uint16 crypto_uint16_x) {
*crypto_uint16_s++ = crypto_uint16_x >> 8;
*crypto_uint16_s++ = crypto_uint16_x >> 0;
}
__attribute__((unused))
static inline
crypto_uint16_signed crypto_uint16_signed_negative_mask(crypto_uint16_signed crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarw $15,%0" : "+r"(crypto_uint16_x) : : "cc");
return crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16_signed crypto_uint16_y;
__asm__ ("sbfx %w0,%w1,15,1" : "=r"(crypto_uint16_y) : "r"(crypto_uint16_x) : );
return crypto_uint16_y;
#else
crypto_uint16_x >>= 16-6;
crypto_uint16_x += crypto_uint16_signed_optblocker;
crypto_uint16_x >>= 5;
return crypto_uint16_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_topbit_01(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrw $15,%0" : "+r"(crypto_uint16_x) : : "cc");
return crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16_signed crypto_uint16_y;
__asm__ ("ubfx %w0,%w1,15,1" : "=r"(crypto_uint16_y) : "r"(crypto_uint16_x) : );
return crypto_uint16_y;
#else
crypto_uint16_x >>= 16-6;
crypto_uint16_x += crypto_uint16_signed_optblocker;
crypto_uint16_x >>= 5;
return crypto_uint16_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_topbit_mask(crypto_uint16 crypto_uint16_x) {
return crypto_uint16_signed_negative_mask(crypto_uint16_x);
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_bottombit_mask(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andw $1,%0" : "+r"(crypto_uint16_x) : : "cc");
return -crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_y;
__asm__ ("sbfx %w0,%w1,0,1" : "=r"(crypto_uint16_y) : "r"(crypto_uint16_x) : );
return crypto_uint16_y;
#else
crypto_uint16_x &= 1 + crypto_uint16_signed_optblocker;
return -crypto_uint16_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_bottombit_01(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andw $1,%0" : "+r"(crypto_uint16_x) : : "cc");
return crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_y;
__asm__ ("ubfx %w0,%w1,0,1" : "=r"(crypto_uint16_y) : "r"(crypto_uint16_x) : );
return crypto_uint16_y;
#else
crypto_uint16_x &= 1 + crypto_uint16_signed_optblocker;
return crypto_uint16_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_bitinrangepublicpos_mask(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrw %%cl,%0" : "+r"(crypto_uint16_x) : "c"(crypto_uint16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,65535\n lsr %w0,%w0,%w1" : "+&r"(crypto_uint16_x) : "r"(crypto_uint16_s) : );
#else
crypto_uint16_x >>= crypto_uint16_s ^ crypto_uint16_signed_optblocker;
#endif
return crypto_uint16_bottombit_mask(crypto_uint16_x);
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_bitinrangepublicpos_01(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrw %%cl,%0" : "+r"(crypto_uint16_x) : "c"(crypto_uint16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,65535\n lsr %w0,%w0,%w1" : "+&r"(crypto_uint16_x) : "r"(crypto_uint16_s) : );
#else
crypto_uint16_x >>= crypto_uint16_s ^ crypto_uint16_signed_optblocker;
#endif
return crypto_uint16_bottombit_01(crypto_uint16_x);
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_shlmod(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16_s &= 15;
__asm__ ("shlw %%cl,%0" : "+r"(crypto_uint16_x) : "c"(crypto_uint16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,15\n and %w1,%w1,65535\n lsl %w1,%w1,%w0" : "+&r"(crypto_uint16_s), "+r"(crypto_uint16_x) : : );
#else
int crypto_uint16_k, crypto_uint16_l;
for (crypto_uint16_l = 0,crypto_uint16_k = 1;crypto_uint16_k < 16;++crypto_uint16_l,crypto_uint16_k *= 2)
crypto_uint16_x ^= (crypto_uint16_x ^ (crypto_uint16_x << crypto_uint16_k)) & crypto_uint16_bitinrangepublicpos_mask(crypto_uint16_s,crypto_uint16_l);
#endif
return crypto_uint16_x;
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_shrmod(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16_s &= 15;
__asm__ ("shrw %%cl,%0" : "+r"(crypto_uint16_x) : "c"(crypto_uint16_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,15\n and %w1,%w1,65535\n lsr %w1,%w1,%w0" : "+&r"(crypto_uint16_s), "+r"(crypto_uint16_x) : : );
#else
int crypto_uint16_k, crypto_uint16_l;
for (crypto_uint16_l = 0,crypto_uint16_k = 1;crypto_uint16_k < 16;++crypto_uint16_l,crypto_uint16_k *= 2)
crypto_uint16_x ^= (crypto_uint16_x ^ (crypto_uint16_x >> crypto_uint16_k)) & crypto_uint16_bitinrangepublicpos_mask(crypto_uint16_s,crypto_uint16_l);
#endif
return crypto_uint16_x;
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_bitmod_mask(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_s) {
crypto_uint16_x = crypto_uint16_shrmod(crypto_uint16_x,crypto_uint16_s);
return crypto_uint16_bottombit_mask(crypto_uint16_x);
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_bitmod_01(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_s) {
crypto_uint16_x = crypto_uint16_shrmod(crypto_uint16_x,crypto_uint16_s);
return crypto_uint16_bottombit_01(crypto_uint16_x);
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_nonzero_mask(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n testw %2,%2\n cmovnew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("tst %w1,65535\n csetm %w0,ne" : "=r"(crypto_uint16_z) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#else
crypto_uint16_x |= -crypto_uint16_x;
return crypto_uint16_signed_negative_mask(crypto_uint16_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_nonzero_01(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n testw %2,%2\n cmovnew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("tst %w1,65535\n cset %w0,ne" : "=r"(crypto_uint16_z) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#else
crypto_uint16_x |= -crypto_uint16_x;
return crypto_uint16_topbit_01(crypto_uint16_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_zero_mask(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n testw %2,%2\n cmovew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("tst %w1,65535\n csetm %w0,eq" : "=r"(crypto_uint16_z) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#else
return ~crypto_uint16_nonzero_mask(crypto_uint16_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_zero_01(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n testw %2,%2\n cmovew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("tst %w1,65535\n cset %w0,eq" : "=r"(crypto_uint16_z) : "r"(crypto_uint16_x) : "cc");
return crypto_uint16_z;
#else
return 1-crypto_uint16_nonzero_01(crypto_uint16_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_unequal_mask(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovnew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n csetm %w0,ne" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
return crypto_uint16_nonzero_mask(crypto_uint16_x ^ crypto_uint16_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_unequal_01(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovnew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n cset %w0,ne" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
return crypto_uint16_nonzero_01(crypto_uint16_x ^ crypto_uint16_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_equal_mask(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n csetm %w0,eq" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
return ~crypto_uint16_unequal_mask(crypto_uint16_x,crypto_uint16_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_equal_01(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n cset %w0,eq" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
return 1-crypto_uint16_unequal_01(crypto_uint16_x,crypto_uint16_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_min(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpw %1,%0\n cmovaw %1,%0" : "+r"(crypto_uint16_x) : "r"(crypto_uint16_y) : "cc");
return crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,65535\n cmp %w0,%w1,uxth\n csel %w0,%w0,%w1,lo" : "+&r"(crypto_uint16_x) : "r"(crypto_uint16_y) : "cc");
return crypto_uint16_x;
#else
crypto_uint16 crypto_uint16_r = crypto_uint16_y ^ crypto_uint16_x;
crypto_uint16 crypto_uint16_z = crypto_uint16_y - crypto_uint16_x;
crypto_uint16_z ^= crypto_uint16_r & (crypto_uint16_z ^ crypto_uint16_y ^ (((crypto_uint16) 1) << (16-1)));
crypto_uint16_z = crypto_uint16_signed_negative_mask(crypto_uint16_z);
crypto_uint16_z &= crypto_uint16_r;
return crypto_uint16_x ^ crypto_uint16_z;
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_max(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpw %1,%0\n cmovbw %1,%0" : "+r"(crypto_uint16_x) : "r"(crypto_uint16_y) : "cc");
return crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,65535\n cmp %w0,%w1,uxth\n csel %w0,%w1,%w0,lo" : "+&r"(crypto_uint16_x) : "r"(crypto_uint16_y) : "cc");
return crypto_uint16_x;
#else
crypto_uint16 crypto_uint16_r = crypto_uint16_y ^ crypto_uint16_x;
crypto_uint16 crypto_uint16_z = crypto_uint16_y - crypto_uint16_x;
crypto_uint16_z ^= crypto_uint16_r & (crypto_uint16_z ^ crypto_uint16_y ^ (((crypto_uint16) 1) << (16-1)));
crypto_uint16_z = crypto_uint16_signed_negative_mask(crypto_uint16_z);
crypto_uint16_z &= crypto_uint16_r;
return crypto_uint16_y ^ crypto_uint16_z;
#endif
}
__attribute__((unused))
static inline
void crypto_uint16_minmax(crypto_uint16 *crypto_uint16_p,crypto_uint16 *crypto_uint16_q) {
crypto_uint16 crypto_uint16_x = *crypto_uint16_p;
crypto_uint16 crypto_uint16_y = *crypto_uint16_q;
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("cmpw %2,%1\n movw %1,%0\n cmovaw %2,%1\n cmovaw %0,%2" : "=&r"(crypto_uint16_z), "+&r"(crypto_uint16_x), "+r"(crypto_uint16_y) : : "cc");
*crypto_uint16_p = crypto_uint16_x;
*crypto_uint16_q = crypto_uint16_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_r, crypto_uint16_s;
__asm__ ("and %w0,%w0,65535\n cmp %w0,%w3,uxth\n csel %w1,%w0,%w3,lo\n csel %w2,%w3,%w0,lo" : "+&r"(crypto_uint16_x), "=&r"(crypto_uint16_r), "=r"(crypto_uint16_s) : "r"(crypto_uint16_y) : "cc");
*crypto_uint16_p = crypto_uint16_r;
*crypto_uint16_q = crypto_uint16_s;
#else
crypto_uint16 crypto_uint16_r = crypto_uint16_y ^ crypto_uint16_x;
crypto_uint16 crypto_uint16_z = crypto_uint16_y - crypto_uint16_x;
crypto_uint16_z ^= crypto_uint16_r & (crypto_uint16_z ^ crypto_uint16_y ^ (((crypto_uint16) 1) << (16-1)));
crypto_uint16_z = crypto_uint16_signed_negative_mask(crypto_uint16_z);
crypto_uint16_z &= crypto_uint16_r;
crypto_uint16_x ^= crypto_uint16_z;
crypto_uint16_y ^= crypto_uint16_z;
*crypto_uint16_p = crypto_uint16_x;
*crypto_uint16_q = crypto_uint16_y;
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_smaller_mask(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovbw %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n csetm %w0,lo" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
crypto_uint16 crypto_uint16_r = crypto_uint16_x ^ crypto_uint16_y;
crypto_uint16 crypto_uint16_z = crypto_uint16_x - crypto_uint16_y;
crypto_uint16_z ^= crypto_uint16_r & (crypto_uint16_z ^ crypto_uint16_x ^ (((crypto_uint16) 1) << (16-1)));
return crypto_uint16_signed_negative_mask(crypto_uint16_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_smaller_01(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovbw %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n cset %w0,lo" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
crypto_uint16 crypto_uint16_r = crypto_uint16_x ^ crypto_uint16_y;
crypto_uint16 crypto_uint16_z = crypto_uint16_x - crypto_uint16_y;
crypto_uint16_z ^= crypto_uint16_r & (crypto_uint16_z ^ crypto_uint16_x ^ (((crypto_uint16) 1) << (16-1)));
return crypto_uint16_topbit_01(crypto_uint16_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_leq_mask(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $-1,%1\n cmpw %3,%2\n cmovbew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n csetm %w0,ls" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
return ~crypto_uint16_smaller_mask(crypto_uint16_y,crypto_uint16_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint16 crypto_uint16_leq_01(crypto_uint16 crypto_uint16_x,crypto_uint16 crypto_uint16_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 crypto_uint16_q,crypto_uint16_z;
__asm__ ("xorw %0,%0\n movw $1,%1\n cmpw %3,%2\n cmovbew %1,%0" : "=&r"(crypto_uint16_z), "=&r"(crypto_uint16_q) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint16 crypto_uint16_z;
__asm__ ("and %w0,%w1,65535\n cmp %w0,%w2,uxth\n cset %w0,ls" : "=&r"(crypto_uint16_z) : "r"(crypto_uint16_x), "r"(crypto_uint16_y) : "cc");
return crypto_uint16_z;
#else
return 1-crypto_uint16_smaller_01(crypto_uint16_y,crypto_uint16_x);
#endif
}
__attribute__((unused))
static inline
int crypto_uint16_ones_num(crypto_uint16 crypto_uint16_x) {
crypto_uint16 crypto_uint16_y = crypto_uint16_x;
const crypto_uint16 C0 = 0x5555;
const crypto_uint16 C1 = 0x3333;
const crypto_uint16 C2 = 0x0f0f;
crypto_uint16_y -= ((crypto_uint16_y >> 1) & C0);
crypto_uint16_y = (crypto_uint16_y & C1) + ((crypto_uint16_y >> 2) & C1);
crypto_uint16_y = (crypto_uint16_y + (crypto_uint16_y >> 4)) & C2;
crypto_uint16_y = (crypto_uint16_y + (crypto_uint16_y >> 8)) & 0xff;
return crypto_uint16_y;
}
__attribute__((unused))
static inline
int crypto_uint16_bottomzeros_num(crypto_uint16 crypto_uint16_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint16 fallback = 16;
__asm__ ("bsfw %0,%0\n cmovew %1,%0" : "+&r"(crypto_uint16_x) : "r"(fallback) : "cc");
return crypto_uint16_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_uint16_y;
__asm__ ("orr %w0,%w1,-65536\n rbit %w0,%w0\n clz %w0,%w0" : "=r"(crypto_uint16_y) : "r"(crypto_uint16_x) : );
return crypto_uint16_y;
#else
crypto_uint16 crypto_uint16_y = crypto_uint16_x ^ (crypto_uint16_x-1);
crypto_uint16_y = ((crypto_uint16_signed) crypto_uint16_y) >> 1;
crypto_uint16_y &= ~(crypto_uint16_x & (((crypto_uint16) 1) << (16-1)));
return crypto_uint16_ones_num(crypto_uint16_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_uint32.h 0000664 0000000 0000000 00000051141 14745512304 0020415 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_uint32_h
#define crypto_uint32_h
#include
#define crypto_uint32 uint32_t
#define crypto_uint32_signed int32_t
#define crypto_uint32_signed_optblocker tinyssh_uint32_signed_optblocker
extern volatile crypto_uint32_signed crypto_uint32_signed_optblocker;
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_load(const unsigned char *crypto_uint32_s) {
crypto_uint32 crypto_uint32_z = 0;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 0;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 8;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 16;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 24;
return crypto_uint32_z;
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_load_bigendian(const unsigned char *crypto_uint32_s) {
crypto_uint32 crypto_uint32_z = 0;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 24;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 16;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 8;
crypto_uint32_z |= ((crypto_uint32) (*crypto_uint32_s++)) << 0;
return crypto_uint32_z;
}
__attribute__((unused))
static inline
void crypto_uint32_store(unsigned char *crypto_uint32_s,crypto_uint32 crypto_uint32_x) {
*crypto_uint32_s++ = crypto_uint32_x >> 0;
*crypto_uint32_s++ = crypto_uint32_x >> 8;
*crypto_uint32_s++ = crypto_uint32_x >> 16;
*crypto_uint32_s++ = crypto_uint32_x >> 24;
}
__attribute__((unused))
static inline
void crypto_uint32_store_bigendian(unsigned char *crypto_uint32_s,crypto_uint32 crypto_uint32_x) {
*crypto_uint32_s++ = crypto_uint32_x >> 24;
*crypto_uint32_s++ = crypto_uint32_x >> 16;
*crypto_uint32_s++ = crypto_uint32_x >> 8;
*crypto_uint32_s++ = crypto_uint32_x >> 0;
}
__attribute__((unused))
static inline
crypto_uint32_signed crypto_uint32_signed_negative_mask(crypto_uint32_signed crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarl $31,%0" : "+r"(crypto_uint32_x) : : "cc");
return crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32_signed crypto_uint32_y;
__asm__ ("asr %w0,%w1,31" : "=r"(crypto_uint32_y) : "r"(crypto_uint32_x) : );
return crypto_uint32_y;
#else
crypto_uint32_x >>= 32-6;
crypto_uint32_x += crypto_uint32_signed_optblocker;
crypto_uint32_x >>= 5;
return crypto_uint32_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_topbit_01(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrl $31,%0" : "+r"(crypto_uint32_x) : : "cc");
return crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32_signed crypto_uint32_y;
__asm__ ("lsr %w0,%w1,31" : "=r"(crypto_uint32_y) : "r"(crypto_uint32_x) : );
return crypto_uint32_y;
#else
crypto_uint32_x >>= 32-6;
crypto_uint32_x += crypto_uint32_signed_optblocker;
crypto_uint32_x >>= 5;
return crypto_uint32_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_topbit_mask(crypto_uint32 crypto_uint32_x) {
return crypto_uint32_signed_negative_mask(crypto_uint32_x);
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_bottombit_mask(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andl $1,%0" : "+r"(crypto_uint32_x) : : "cc");
return -crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_y;
__asm__ ("sbfx %w0,%w1,0,1" : "=r"(crypto_uint32_y) : "r"(crypto_uint32_x) : );
return crypto_uint32_y;
#else
crypto_uint32_x &= 1 + crypto_uint32_signed_optblocker;
return -crypto_uint32_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_bottombit_01(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andl $1,%0" : "+r"(crypto_uint32_x) : : "cc");
return crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_y;
__asm__ ("ubfx %w0,%w1,0,1" : "=r"(crypto_uint32_y) : "r"(crypto_uint32_x) : );
return crypto_uint32_y;
#else
crypto_uint32_x &= 1 + crypto_uint32_signed_optblocker;
return crypto_uint32_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_bitinrangepublicpos_mask(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrl %%cl,%0" : "+r"(crypto_uint32_x) : "c"(crypto_uint32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsr %w0,%w0,%w1" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_s) : );
#else
crypto_uint32_x >>= crypto_uint32_s ^ crypto_uint32_signed_optblocker;
#endif
return crypto_uint32_bottombit_mask(crypto_uint32_x);
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_bitinrangepublicpos_01(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrl %%cl,%0" : "+r"(crypto_uint32_x) : "c"(crypto_uint32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsr %w0,%w0,%w1" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_s) : );
#else
crypto_uint32_x >>= crypto_uint32_s ^ crypto_uint32_signed_optblocker;
#endif
return crypto_uint32_bottombit_01(crypto_uint32_x);
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_shlmod(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shll %%cl,%0" : "+r"(crypto_uint32_x) : "c"(crypto_uint32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsl %w0,%w0,%w1" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_s) : );
#else
int crypto_uint32_k, crypto_uint32_l;
for (crypto_uint32_l = 0,crypto_uint32_k = 1;crypto_uint32_k < 32;++crypto_uint32_l,crypto_uint32_k *= 2)
crypto_uint32_x ^= (crypto_uint32_x ^ (crypto_uint32_x << crypto_uint32_k)) & crypto_uint32_bitinrangepublicpos_mask(crypto_uint32_s,crypto_uint32_l);
#endif
return crypto_uint32_x;
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_shrmod(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrl %%cl,%0" : "+r"(crypto_uint32_x) : "c"(crypto_uint32_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsr %w0,%w0,%w1" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_s) : );
#else
int crypto_uint32_k, crypto_uint32_l;
for (crypto_uint32_l = 0,crypto_uint32_k = 1;crypto_uint32_k < 32;++crypto_uint32_l,crypto_uint32_k *= 2)
crypto_uint32_x ^= (crypto_uint32_x ^ (crypto_uint32_x >> crypto_uint32_k)) & crypto_uint32_bitinrangepublicpos_mask(crypto_uint32_s,crypto_uint32_l);
#endif
return crypto_uint32_x;
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_bitmod_mask(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_s) {
crypto_uint32_x = crypto_uint32_shrmod(crypto_uint32_x,crypto_uint32_s);
return crypto_uint32_bottombit_mask(crypto_uint32_x);
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_bitmod_01(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_s) {
crypto_uint32_x = crypto_uint32_shrmod(crypto_uint32_x,crypto_uint32_s);
return crypto_uint32_bottombit_01(crypto_uint32_x);
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_nonzero_mask(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testl %2,%2\n cmovnel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,0\n csetm %w0,ne" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#else
crypto_uint32_x |= -crypto_uint32_x;
return crypto_uint32_signed_negative_mask(crypto_uint32_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_nonzero_01(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n testl %2,%2\n cmovnel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,0\n cset %w0,ne" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#else
crypto_uint32_x |= -crypto_uint32_x;
return crypto_uint32_topbit_01(crypto_uint32_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_zero_mask(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testl %2,%2\n cmovel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,0\n csetm %w0,eq" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#else
return ~crypto_uint32_nonzero_mask(crypto_uint32_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_zero_01(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n testl %2,%2\n cmovel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,0\n cset %w0,eq" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x) : "cc");
return crypto_uint32_z;
#else
return 1-crypto_uint32_nonzero_01(crypto_uint32_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_unequal_mask(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovnel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,ne" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
return crypto_uint32_nonzero_mask(crypto_uint32_x ^ crypto_uint32_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_unequal_01(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovnel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,ne" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
return crypto_uint32_nonzero_01(crypto_uint32_x ^ crypto_uint32_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_equal_mask(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,eq" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
return ~crypto_uint32_unequal_mask(crypto_uint32_x,crypto_uint32_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_equal_01(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,eq" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
return 1-crypto_uint32_unequal_01(crypto_uint32_x,crypto_uint32_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_min(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpl %1,%0\n cmoval %1,%0" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_y) : "cc");
return crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %w0,%w1\n csel %w0,%w0,%w1,lo" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_y) : "cc");
return crypto_uint32_x;
#else
crypto_uint32 crypto_uint32_r = crypto_uint32_y ^ crypto_uint32_x;
crypto_uint32 crypto_uint32_z = crypto_uint32_y - crypto_uint32_x;
crypto_uint32_z ^= crypto_uint32_r & (crypto_uint32_z ^ crypto_uint32_y ^ (((crypto_uint32) 1) << (32-1)));
crypto_uint32_z = crypto_uint32_signed_negative_mask(crypto_uint32_z);
crypto_uint32_z &= crypto_uint32_r;
return crypto_uint32_x ^ crypto_uint32_z;
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_max(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpl %1,%0\n cmovbl %1,%0" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_y) : "cc");
return crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %w0,%w1\n csel %w0,%w1,%w0,lo" : "+r"(crypto_uint32_x) : "r"(crypto_uint32_y) : "cc");
return crypto_uint32_x;
#else
crypto_uint32 crypto_uint32_r = crypto_uint32_y ^ crypto_uint32_x;
crypto_uint32 crypto_uint32_z = crypto_uint32_y - crypto_uint32_x;
crypto_uint32_z ^= crypto_uint32_r & (crypto_uint32_z ^ crypto_uint32_y ^ (((crypto_uint32) 1) << (32-1)));
crypto_uint32_z = crypto_uint32_signed_negative_mask(crypto_uint32_z);
crypto_uint32_z &= crypto_uint32_r;
return crypto_uint32_y ^ crypto_uint32_z;
#endif
}
__attribute__((unused))
static inline
void crypto_uint32_minmax(crypto_uint32 *crypto_uint32_p,crypto_uint32 *crypto_uint32_q) {
crypto_uint32 crypto_uint32_x = *crypto_uint32_p;
crypto_uint32 crypto_uint32_y = *crypto_uint32_q;
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmpl %2,%1\n movl %1,%0\n cmoval %2,%1\n cmoval %0,%2" : "=&r"(crypto_uint32_z), "+&r"(crypto_uint32_x), "+r"(crypto_uint32_y) : : "cc");
*crypto_uint32_p = crypto_uint32_x;
*crypto_uint32_q = crypto_uint32_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_r, crypto_uint32_s;
__asm__ ("cmp %w2,%w3\n csel %w0,%w2,%w3,lo\n csel %w1,%w3,%w2,lo" : "=&r"(crypto_uint32_r), "=r"(crypto_uint32_s) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
*crypto_uint32_p = crypto_uint32_r;
*crypto_uint32_q = crypto_uint32_s;
#else
crypto_uint32 crypto_uint32_r = crypto_uint32_y ^ crypto_uint32_x;
crypto_uint32 crypto_uint32_z = crypto_uint32_y - crypto_uint32_x;
crypto_uint32_z ^= crypto_uint32_r & (crypto_uint32_z ^ crypto_uint32_y ^ (((crypto_uint32) 1) << (32-1)));
crypto_uint32_z = crypto_uint32_signed_negative_mask(crypto_uint32_z);
crypto_uint32_z &= crypto_uint32_r;
crypto_uint32_x ^= crypto_uint32_z;
crypto_uint32_y ^= crypto_uint32_z;
*crypto_uint32_p = crypto_uint32_x;
*crypto_uint32_q = crypto_uint32_y;
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_smaller_mask(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovbl %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,lo" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
crypto_uint32 crypto_uint32_r = crypto_uint32_x ^ crypto_uint32_y;
crypto_uint32 crypto_uint32_z = crypto_uint32_x - crypto_uint32_y;
crypto_uint32_z ^= crypto_uint32_r & (crypto_uint32_z ^ crypto_uint32_x ^ (((crypto_uint32) 1) << (32-1)));
return crypto_uint32_signed_negative_mask(crypto_uint32_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_smaller_01(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovbl %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,lo" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
crypto_uint32 crypto_uint32_r = crypto_uint32_x ^ crypto_uint32_y;
crypto_uint32 crypto_uint32_z = crypto_uint32_x - crypto_uint32_y;
crypto_uint32_z ^= crypto_uint32_r & (crypto_uint32_z ^ crypto_uint32_x ^ (((crypto_uint32) 1) << (32-1)));
return crypto_uint32_topbit_01(crypto_uint32_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_leq_mask(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpl %3,%2\n cmovbel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n csetm %w0,ls" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
return ~crypto_uint32_smaller_mask(crypto_uint32_y,crypto_uint32_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint32 crypto_uint32_leq_01(crypto_uint32 crypto_uint32_x,crypto_uint32 crypto_uint32_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 crypto_uint32_q,crypto_uint32_z;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpl %3,%2\n cmovbel %1,%0" : "=&r"(crypto_uint32_z), "=&r"(crypto_uint32_q) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint32 crypto_uint32_z;
__asm__ ("cmp %w1,%w2\n cset %w0,ls" : "=r"(crypto_uint32_z) : "r"(crypto_uint32_x), "r"(crypto_uint32_y) : "cc");
return crypto_uint32_z;
#else
return 1-crypto_uint32_smaller_01(crypto_uint32_y,crypto_uint32_x);
#endif
}
__attribute__((unused))
static inline
int crypto_uint32_ones_num(crypto_uint32 crypto_uint32_x) {
crypto_uint32 crypto_uint32_y = crypto_uint32_x;
const crypto_uint32 C0 = 0x55555555;
const crypto_uint32 C1 = 0x33333333;
const crypto_uint32 C2 = 0x0f0f0f0f;
crypto_uint32_y -= ((crypto_uint32_y >> 1) & C0);
crypto_uint32_y = (crypto_uint32_y & C1) + ((crypto_uint32_y >> 2) & C1);
crypto_uint32_y = (crypto_uint32_y + (crypto_uint32_y >> 4)) & C2;
crypto_uint32_y += crypto_uint32_y >> 8;
crypto_uint32_y = (crypto_uint32_y + (crypto_uint32_y >> 16)) & 0xff;
return crypto_uint32_y;
}
__attribute__((unused))
static inline
int crypto_uint32_bottomzeros_num(crypto_uint32 crypto_uint32_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint32 fallback = 32;
__asm__ ("bsfl %0,%0\n cmovel %1,%0" : "+&r"(crypto_uint32_x) : "r"(fallback) : "cc");
return crypto_uint32_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_uint32_y;
__asm__ ("rbit %w0,%w1\n clz %w0,%w0" : "=r"(crypto_uint32_y) : "r"(crypto_uint32_x) : );
return crypto_uint32_y;
#else
crypto_uint32 crypto_uint32_y = crypto_uint32_x ^ (crypto_uint32_x-1);
crypto_uint32_y = ((crypto_uint32_signed) crypto_uint32_y) >> 1;
crypto_uint32_y &= ~(crypto_uint32_x & (((crypto_uint32) 1) << (32-1)));
return crypto_uint32_ones_num(crypto_uint32_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_uint64.h 0000664 0000000 0000000 00000052743 14745512304 0020433 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_uint64_h
#define crypto_uint64_h
#include
#define crypto_uint64 uint64_t
#define crypto_uint64_signed int64_t
#define crypto_uint64_signed_optblocker tinyssh_uint64_signed_optblocker
extern volatile crypto_uint64_signed crypto_uint64_signed_optblocker;
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_load(const unsigned char *crypto_uint64_s) {
crypto_uint64 crypto_uint64_z = 0;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 0;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 8;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 16;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 24;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 32;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 40;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 48;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 56;
return crypto_uint64_z;
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_load_bigendian(const unsigned char *crypto_uint64_s) {
crypto_uint64 crypto_uint64_z = 0;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 56;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 48;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 40;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 32;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 24;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 16;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 8;
crypto_uint64_z |= ((crypto_uint64) (*crypto_uint64_s++)) << 0;
return crypto_uint64_z;
}
__attribute__((unused))
static inline
void crypto_uint64_store(unsigned char *crypto_uint64_s,crypto_uint64 crypto_uint64_x) {
*crypto_uint64_s++ = crypto_uint64_x >> 0;
*crypto_uint64_s++ = crypto_uint64_x >> 8;
*crypto_uint64_s++ = crypto_uint64_x >> 16;
*crypto_uint64_s++ = crypto_uint64_x >> 24;
*crypto_uint64_s++ = crypto_uint64_x >> 32;
*crypto_uint64_s++ = crypto_uint64_x >> 40;
*crypto_uint64_s++ = crypto_uint64_x >> 48;
*crypto_uint64_s++ = crypto_uint64_x >> 56;
}
__attribute__((unused))
static inline
void crypto_uint64_store_bigendian(unsigned char *crypto_uint64_s,crypto_uint64 crypto_uint64_x) {
*crypto_uint64_s++ = crypto_uint64_x >> 56;
*crypto_uint64_s++ = crypto_uint64_x >> 48;
*crypto_uint64_s++ = crypto_uint64_x >> 40;
*crypto_uint64_s++ = crypto_uint64_x >> 32;
*crypto_uint64_s++ = crypto_uint64_x >> 24;
*crypto_uint64_s++ = crypto_uint64_x >> 16;
*crypto_uint64_s++ = crypto_uint64_x >> 8;
*crypto_uint64_s++ = crypto_uint64_x >> 0;
}
__attribute__((unused))
static inline
crypto_uint64_signed crypto_uint64_signed_negative_mask(crypto_uint64_signed crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarq $63,%0" : "+r"(crypto_uint64_x) : : "cc");
return crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64_signed crypto_uint64_y;
__asm__ ("asr %0,%1,63" : "=r"(crypto_uint64_y) : "r"(crypto_uint64_x) : );
return crypto_uint64_y;
#else
crypto_uint64_x >>= 64-6;
crypto_uint64_x += crypto_uint64_signed_optblocker;
crypto_uint64_x >>= 5;
return crypto_uint64_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_topbit_01(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrq $63,%0" : "+r"(crypto_uint64_x) : : "cc");
return crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64_signed crypto_uint64_y;
__asm__ ("lsr %0,%1,63" : "=r"(crypto_uint64_y) : "r"(crypto_uint64_x) : );
return crypto_uint64_y;
#else
crypto_uint64_x >>= 64-6;
crypto_uint64_x += crypto_uint64_signed_optblocker;
crypto_uint64_x >>= 5;
return crypto_uint64_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_topbit_mask(crypto_uint64 crypto_uint64_x) {
return crypto_uint64_signed_negative_mask(crypto_uint64_x);
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_bottombit_mask(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andq $1,%0" : "+r"(crypto_uint64_x) : : "cc");
return -crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_y;
__asm__ ("sbfx %0,%1,0,1" : "=r"(crypto_uint64_y) : "r"(crypto_uint64_x) : );
return crypto_uint64_y;
#else
crypto_uint64_x &= 1 + crypto_uint64_signed_optblocker;
return -crypto_uint64_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_bottombit_01(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andq $1,%0" : "+r"(crypto_uint64_x) : : "cc");
return crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_y;
__asm__ ("ubfx %0,%1,0,1" : "=r"(crypto_uint64_y) : "r"(crypto_uint64_x) : );
return crypto_uint64_y;
#else
crypto_uint64_x &= 1 + crypto_uint64_signed_optblocker;
return crypto_uint64_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_bitinrangepublicpos_mask(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrq %%cl,%0" : "+r"(crypto_uint64_x) : "c"(crypto_uint64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsr %0,%0,%1" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_s) : );
#else
crypto_uint64_x >>= crypto_uint64_s ^ crypto_uint64_signed_optblocker;
#endif
return crypto_uint64_bottombit_mask(crypto_uint64_x);
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_bitinrangepublicpos_01(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrq %%cl,%0" : "+r"(crypto_uint64_x) : "c"(crypto_uint64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsr %0,%0,%1" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_s) : );
#else
crypto_uint64_x >>= crypto_uint64_s ^ crypto_uint64_signed_optblocker;
#endif
return crypto_uint64_bottombit_01(crypto_uint64_x);
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_shlmod(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shlq %%cl,%0" : "+r"(crypto_uint64_x) : "c"(crypto_uint64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsl %0,%0,%1" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_s) : );
#else
int crypto_uint64_k, crypto_uint64_l;
for (crypto_uint64_l = 0,crypto_uint64_k = 1;crypto_uint64_k < 64;++crypto_uint64_l,crypto_uint64_k *= 2)
crypto_uint64_x ^= (crypto_uint64_x ^ (crypto_uint64_x << crypto_uint64_k)) & crypto_uint64_bitinrangepublicpos_mask(crypto_uint64_s,crypto_uint64_l);
#endif
return crypto_uint64_x;
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_shrmod(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrq %%cl,%0" : "+r"(crypto_uint64_x) : "c"(crypto_uint64_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("lsr %0,%0,%1" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_s) : );
#else
int crypto_uint64_k, crypto_uint64_l;
for (crypto_uint64_l = 0,crypto_uint64_k = 1;crypto_uint64_k < 64;++crypto_uint64_l,crypto_uint64_k *= 2)
crypto_uint64_x ^= (crypto_uint64_x ^ (crypto_uint64_x >> crypto_uint64_k)) & crypto_uint64_bitinrangepublicpos_mask(crypto_uint64_s,crypto_uint64_l);
#endif
return crypto_uint64_x;
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_bitmod_mask(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_s) {
crypto_uint64_x = crypto_uint64_shrmod(crypto_uint64_x,crypto_uint64_s);
return crypto_uint64_bottombit_mask(crypto_uint64_x);
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_bitmod_01(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_s) {
crypto_uint64_x = crypto_uint64_shrmod(crypto_uint64_x,crypto_uint64_s);
return crypto_uint64_bottombit_01(crypto_uint64_x);
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_nonzero_mask(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n testq %2,%2\n cmovneq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,0\n csetm %0,ne" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#else
crypto_uint64_x |= -crypto_uint64_x;
return crypto_uint64_signed_negative_mask(crypto_uint64_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_nonzero_01(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n testq %2,%2\n cmovneq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,0\n cset %0,ne" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#else
crypto_uint64_x |= -crypto_uint64_x;
return crypto_uint64_topbit_01(crypto_uint64_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_zero_mask(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n testq %2,%2\n cmoveq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,0\n csetm %0,eq" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#else
return ~crypto_uint64_nonzero_mask(crypto_uint64_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_zero_01(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n testq %2,%2\n cmoveq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,0\n cset %0,eq" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x) : "cc");
return crypto_uint64_z;
#else
return 1-crypto_uint64_nonzero_01(crypto_uint64_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_unequal_mask(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmovneq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n csetm %0,ne" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
return crypto_uint64_nonzero_mask(crypto_uint64_x ^ crypto_uint64_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_unequal_01(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmovneq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n cset %0,ne" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
return crypto_uint64_nonzero_01(crypto_uint64_x ^ crypto_uint64_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_equal_mask(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmoveq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n csetm %0,eq" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
return ~crypto_uint64_unequal_mask(crypto_uint64_x,crypto_uint64_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_equal_01(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmoveq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n cset %0,eq" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
return 1-crypto_uint64_unequal_01(crypto_uint64_x,crypto_uint64_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_min(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpq %1,%0\n cmovaq %1,%0" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_y) : "cc");
return crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %0,%1\n csel %0,%0,%1,lo" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_y) : "cc");
return crypto_uint64_x;
#else
crypto_uint64 crypto_uint64_r = crypto_uint64_y ^ crypto_uint64_x;
crypto_uint64 crypto_uint64_z = crypto_uint64_y - crypto_uint64_x;
crypto_uint64_z ^= crypto_uint64_r & (crypto_uint64_z ^ crypto_uint64_y ^ (((crypto_uint64) 1) << (64-1)));
crypto_uint64_z = crypto_uint64_signed_negative_mask(crypto_uint64_z);
crypto_uint64_z &= crypto_uint64_r;
return crypto_uint64_x ^ crypto_uint64_z;
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_max(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("cmpq %1,%0\n cmovbq %1,%0" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_y) : "cc");
return crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("cmp %0,%1\n csel %0,%1,%0,lo" : "+r"(crypto_uint64_x) : "r"(crypto_uint64_y) : "cc");
return crypto_uint64_x;
#else
crypto_uint64 crypto_uint64_r = crypto_uint64_y ^ crypto_uint64_x;
crypto_uint64 crypto_uint64_z = crypto_uint64_y - crypto_uint64_x;
crypto_uint64_z ^= crypto_uint64_r & (crypto_uint64_z ^ crypto_uint64_y ^ (((crypto_uint64) 1) << (64-1)));
crypto_uint64_z = crypto_uint64_signed_negative_mask(crypto_uint64_z);
crypto_uint64_z &= crypto_uint64_r;
return crypto_uint64_y ^ crypto_uint64_z;
#endif
}
__attribute__((unused))
static inline
void crypto_uint64_minmax(crypto_uint64 *crypto_uint64_p,crypto_uint64 *crypto_uint64_q) {
crypto_uint64 crypto_uint64_x = *crypto_uint64_p;
crypto_uint64 crypto_uint64_y = *crypto_uint64_q;
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmpq %2,%1\n movq %1,%0\n cmovaq %2,%1\n cmovaq %0,%2" : "=&r"(crypto_uint64_z), "+&r"(crypto_uint64_x), "+r"(crypto_uint64_y) : : "cc");
*crypto_uint64_p = crypto_uint64_x;
*crypto_uint64_q = crypto_uint64_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_r, crypto_uint64_s;
__asm__ ("cmp %2,%3\n csel %0,%2,%3,lo\n csel %1,%3,%2,lo" : "=&r"(crypto_uint64_r), "=r"(crypto_uint64_s) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
*crypto_uint64_p = crypto_uint64_r;
*crypto_uint64_q = crypto_uint64_s;
#else
crypto_uint64 crypto_uint64_r = crypto_uint64_y ^ crypto_uint64_x;
crypto_uint64 crypto_uint64_z = crypto_uint64_y - crypto_uint64_x;
crypto_uint64_z ^= crypto_uint64_r & (crypto_uint64_z ^ crypto_uint64_y ^ (((crypto_uint64) 1) << (64-1)));
crypto_uint64_z = crypto_uint64_signed_negative_mask(crypto_uint64_z);
crypto_uint64_z &= crypto_uint64_r;
crypto_uint64_x ^= crypto_uint64_z;
crypto_uint64_y ^= crypto_uint64_z;
*crypto_uint64_p = crypto_uint64_x;
*crypto_uint64_q = crypto_uint64_y;
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_smaller_mask(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmovbq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n csetm %0,lo" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
crypto_uint64 crypto_uint64_r = crypto_uint64_x ^ crypto_uint64_y;
crypto_uint64 crypto_uint64_z = crypto_uint64_x - crypto_uint64_y;
crypto_uint64_z ^= crypto_uint64_r & (crypto_uint64_z ^ crypto_uint64_x ^ (((crypto_uint64) 1) << (64-1)));
return crypto_uint64_signed_negative_mask(crypto_uint64_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_smaller_01(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmovbq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n cset %0,lo" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
crypto_uint64 crypto_uint64_r = crypto_uint64_x ^ crypto_uint64_y;
crypto_uint64 crypto_uint64_z = crypto_uint64_x - crypto_uint64_y;
crypto_uint64_z ^= crypto_uint64_r & (crypto_uint64_z ^ crypto_uint64_x ^ (((crypto_uint64) 1) << (64-1)));
return crypto_uint64_topbit_01(crypto_uint64_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_leq_mask(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $-1,%1\n cmpq %3,%2\n cmovbeq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n csetm %0,ls" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
return ~crypto_uint64_smaller_mask(crypto_uint64_y,crypto_uint64_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint64 crypto_uint64_leq_01(crypto_uint64 crypto_uint64_x,crypto_uint64 crypto_uint64_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 crypto_uint64_q,crypto_uint64_z;
__asm__ ("xorq %0,%0\n movq $1,%1\n cmpq %3,%2\n cmovbeq %1,%0" : "=&r"(crypto_uint64_z), "=&r"(crypto_uint64_q) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint64 crypto_uint64_z;
__asm__ ("cmp %1,%2\n cset %0,ls" : "=r"(crypto_uint64_z) : "r"(crypto_uint64_x), "r"(crypto_uint64_y) : "cc");
return crypto_uint64_z;
#else
return 1-crypto_uint64_smaller_01(crypto_uint64_y,crypto_uint64_x);
#endif
}
__attribute__((unused))
static inline
int crypto_uint64_ones_num(crypto_uint64 crypto_uint64_x) {
crypto_uint64 crypto_uint64_y = crypto_uint64_x;
const crypto_uint64 C0 = 0x5555555555555555;
const crypto_uint64 C1 = 0x3333333333333333;
const crypto_uint64 C2 = 0x0f0f0f0f0f0f0f0f;
crypto_uint64_y -= ((crypto_uint64_y >> 1) & C0);
crypto_uint64_y = (crypto_uint64_y & C1) + ((crypto_uint64_y >> 2) & C1);
crypto_uint64_y = (crypto_uint64_y + (crypto_uint64_y >> 4)) & C2;
crypto_uint64_y += crypto_uint64_y >> 8;
crypto_uint64_y += crypto_uint64_y >> 16;
crypto_uint64_y = (crypto_uint64_y + (crypto_uint64_y >> 32)) & 0xff;
return crypto_uint64_y;
}
__attribute__((unused))
static inline
int crypto_uint64_bottomzeros_num(crypto_uint64 crypto_uint64_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint64 fallback = 64;
__asm__ ("bsfq %0,%0\n cmoveq %1,%0" : "+&r"(crypto_uint64_x) : "r"(fallback) : "cc");
return crypto_uint64_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_uint64_y;
__asm__ ("rbit %0,%1\n clz %0,%0" : "=r"(crypto_uint64_y) : "r"(crypto_uint64_x) : );
return crypto_uint64_y;
#else
crypto_uint64 crypto_uint64_y = crypto_uint64_x ^ (crypto_uint64_x-1);
crypto_uint64_y = ((crypto_uint64_signed) crypto_uint64_y) >> 1;
crypto_uint64_y &= ~(crypto_uint64_x & (((crypto_uint64) 1) << (64-1)));
return crypto_uint64_ones_num(crypto_uint64_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_uint8.h 0000664 0000000 0000000 00000053167 14745512304 0020352 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_uint8_h
#define crypto_uint8_h
#include
#define crypto_uint8 uint8_t
#define crypto_uint8_signed int8_t
#define crypto_uint8_signed_optblocker tinyssh_uint8_signed_optblocker
extern volatile crypto_uint8_signed crypto_uint8_signed_optblocker;
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_load(const unsigned char *crypto_uint8_s) {
crypto_uint8 crypto_uint8_z = 0;
crypto_uint8_z |= ((crypto_uint8) (*crypto_uint8_s++)) << 0;
return crypto_uint8_z;
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_load_bigendian(const unsigned char *crypto_uint8_s) {
crypto_uint8 crypto_uint8_z = 0;
crypto_uint8_z |= ((crypto_uint8) (*crypto_uint8_s++)) << 0;
return crypto_uint8_z;
}
__attribute__((unused))
static inline
void crypto_uint8_store(unsigned char *crypto_uint8_s,crypto_uint8 crypto_uint8_x) {
*crypto_uint8_s++ = crypto_uint8_x >> 0;
}
__attribute__((unused))
static inline
void crypto_uint8_store_bigendian(unsigned char *crypto_uint8_s,crypto_uint8 crypto_uint8_x) {
*crypto_uint8_s++ = crypto_uint8_x >> 0;
}
__attribute__((unused))
static inline
crypto_uint8_signed crypto_uint8_signed_negative_mask(crypto_uint8_signed crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("sarb $7,%0" : "+r"(crypto_uint8_x) : : "cc");
return crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8_signed crypto_uint8_y;
__asm__ ("sbfx %w0,%w1,7,1" : "=r"(crypto_uint8_y) : "r"(crypto_uint8_x) : );
return crypto_uint8_y;
#else
crypto_uint8_x >>= 8-6;
crypto_uint8_x += crypto_uint8_signed_optblocker;
crypto_uint8_x >>= 5;
return crypto_uint8_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_topbit_01(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrb $7,%0" : "+r"(crypto_uint8_x) : : "cc");
return crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8_signed crypto_uint8_y;
__asm__ ("ubfx %w0,%w1,7,1" : "=r"(crypto_uint8_y) : "r"(crypto_uint8_x) : );
return crypto_uint8_y;
#else
crypto_uint8_x >>= 8-6;
crypto_uint8_x += crypto_uint8_signed_optblocker;
crypto_uint8_x >>= 5;
return crypto_uint8_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_topbit_mask(crypto_uint8 crypto_uint8_x) {
return crypto_uint8_signed_negative_mask(crypto_uint8_x);
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_bottombit_mask(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andb $1,%0" : "+r"(crypto_uint8_x) : : "cc");
return -crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_y;
__asm__ ("sbfx %w0,%w1,0,1" : "=r"(crypto_uint8_y) : "r"(crypto_uint8_x) : );
return crypto_uint8_y;
#else
crypto_uint8_x &= 1 + crypto_uint8_signed_optblocker;
return -crypto_uint8_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_bottombit_01(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("andb $1,%0" : "+r"(crypto_uint8_x) : : "cc");
return crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_y;
__asm__ ("ubfx %w0,%w1,0,1" : "=r"(crypto_uint8_y) : "r"(crypto_uint8_x) : );
return crypto_uint8_y;
#else
crypto_uint8_x &= 1 + crypto_uint8_signed_optblocker;
return crypto_uint8_x;
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_bitinrangepublicpos_mask(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrb %%cl,%0" : "+r"(crypto_uint8_x) : "c"(crypto_uint8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,255\n lsr %w0,%w0,%w1" : "+&r"(crypto_uint8_x) : "r"(crypto_uint8_s) : );
#else
crypto_uint8_x >>= crypto_uint8_s ^ crypto_uint8_signed_optblocker;
#endif
return crypto_uint8_bottombit_mask(crypto_uint8_x);
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_bitinrangepublicpos_01(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
__asm__ ("shrb %%cl,%0" : "+r"(crypto_uint8_x) : "c"(crypto_uint8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,255\n lsr %w0,%w0,%w1" : "+&r"(crypto_uint8_x) : "r"(crypto_uint8_s) : );
#else
crypto_uint8_x >>= crypto_uint8_s ^ crypto_uint8_signed_optblocker;
#endif
return crypto_uint8_bottombit_01(crypto_uint8_x);
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_shlmod(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8_s &= 7;
__asm__ ("shlb %%cl,%0" : "+r"(crypto_uint8_x) : "c"(crypto_uint8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,7\n and %w1,%w1,255\n lsl %w1,%w1,%w0" : "+&r"(crypto_uint8_s), "+r"(crypto_uint8_x) : : );
#else
int crypto_uint8_k, crypto_uint8_l;
for (crypto_uint8_l = 0,crypto_uint8_k = 1;crypto_uint8_k < 8;++crypto_uint8_l,crypto_uint8_k *= 2)
crypto_uint8_x ^= (crypto_uint8_x ^ (crypto_uint8_x << crypto_uint8_k)) & crypto_uint8_bitinrangepublicpos_mask(crypto_uint8_s,crypto_uint8_l);
#endif
return crypto_uint8_x;
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_shrmod(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_s) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8_s &= 7;
__asm__ ("shrb %%cl,%0" : "+r"(crypto_uint8_x) : "c"(crypto_uint8_s) : "cc");
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,7\n and %w1,%w1,255\n lsr %w1,%w1,%w0" : "+&r"(crypto_uint8_s), "+r"(crypto_uint8_x) : : );
#else
int crypto_uint8_k, crypto_uint8_l;
for (crypto_uint8_l = 0,crypto_uint8_k = 1;crypto_uint8_k < 8;++crypto_uint8_l,crypto_uint8_k *= 2)
crypto_uint8_x ^= (crypto_uint8_x ^ (crypto_uint8_x >> crypto_uint8_k)) & crypto_uint8_bitinrangepublicpos_mask(crypto_uint8_s,crypto_uint8_l);
#endif
return crypto_uint8_x;
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_bitmod_mask(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_s) {
crypto_uint8_x = crypto_uint8_shrmod(crypto_uint8_x,crypto_uint8_s);
return crypto_uint8_bottombit_mask(crypto_uint8_x);
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_bitmod_01(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_s) {
crypto_uint8_x = crypto_uint8_shrmod(crypto_uint8_x,crypto_uint8_s);
return crypto_uint8_bottombit_01(crypto_uint8_x);
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_nonzero_mask(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testb %b2,%b2\n cmovnel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("tst %w1,255\n csetm %w0,ne" : "=r"(crypto_uint8_z) : "r"(crypto_uint8_x) : "cc");
return crypto_uint8_z;
#else
crypto_uint8_x |= -crypto_uint8_x;
return crypto_uint8_signed_negative_mask(crypto_uint8_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_nonzero_01(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n testb %b2,%b2\n cmovnel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("tst %w1,255\n cset %w0,ne" : "=r"(crypto_uint8_z) : "r"(crypto_uint8_x) : "cc");
return crypto_uint8_z;
#else
crypto_uint8_x |= -crypto_uint8_x;
return crypto_uint8_topbit_01(crypto_uint8_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_zero_mask(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n testb %b2,%b2\n cmovel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("tst %w1,255\n csetm %w0,eq" : "=r"(crypto_uint8_z) : "r"(crypto_uint8_x) : "cc");
return crypto_uint8_z;
#else
return ~crypto_uint8_nonzero_mask(crypto_uint8_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_zero_01(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n testb %b2,%b2\n cmovel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("tst %w1,255\n cset %w0,eq" : "=r"(crypto_uint8_z) : "r"(crypto_uint8_x) : "cc");
return crypto_uint8_z;
#else
return 1-crypto_uint8_nonzero_01(crypto_uint8_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_unequal_mask(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovnel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n csetm %w0,ne" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
return crypto_uint8_nonzero_mask(crypto_uint8_x ^ crypto_uint8_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_unequal_01(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovnel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n cset %w0,ne" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
return crypto_uint8_nonzero_01(crypto_uint8_x ^ crypto_uint8_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_equal_mask(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n csetm %w0,eq" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
return ~crypto_uint8_unequal_mask(crypto_uint8_x,crypto_uint8_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_equal_01(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n cset %w0,eq" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
return 1-crypto_uint8_unequal_01(crypto_uint8_x,crypto_uint8_y);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_min(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
uint32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y;
__asm__ ("cmpb %b1,%b0\n cmoval %1,%0" : "+q"(crypto_uint8_x32) : "q"(crypto_uint8_y32) : "cc");
crypto_uint8_x = crypto_uint8_x32;
return crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,255\n cmp %w0,%w1,uxtb\n csel %w0,%w0,%w1,lo" : "+&r"(crypto_uint8_x) : "r"(crypto_uint8_y) : "cc");
return crypto_uint8_x;
#else
crypto_uint8 crypto_uint8_r = crypto_uint8_y ^ crypto_uint8_x;
crypto_uint8 crypto_uint8_z = crypto_uint8_y - crypto_uint8_x;
crypto_uint8_z ^= crypto_uint8_r & (crypto_uint8_z ^ crypto_uint8_y ^ (((crypto_uint8) 1) << (8-1)));
crypto_uint8_z = crypto_uint8_signed_negative_mask(crypto_uint8_z);
crypto_uint8_z &= crypto_uint8_r;
return crypto_uint8_x ^ crypto_uint8_z;
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_max(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
uint32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y;
__asm__ ("cmpb %b1,%b0\n cmovbl %1,%0" : "+q"(crypto_uint8_x32) : "q"(crypto_uint8_y32) : "cc");
crypto_uint8_x = crypto_uint8_x32;
return crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
__asm__ ("and %w0,%w0,255\n cmp %w0,%w1,uxtb\n csel %w0,%w1,%w0,lo" : "+&r"(crypto_uint8_x) : "r"(crypto_uint8_y) : "cc");
return crypto_uint8_x;
#else
crypto_uint8 crypto_uint8_r = crypto_uint8_y ^ crypto_uint8_x;
crypto_uint8 crypto_uint8_z = crypto_uint8_y - crypto_uint8_x;
crypto_uint8_z ^= crypto_uint8_r & (crypto_uint8_z ^ crypto_uint8_y ^ (((crypto_uint8) 1) << (8-1)));
crypto_uint8_z = crypto_uint8_signed_negative_mask(crypto_uint8_z);
crypto_uint8_z &= crypto_uint8_r;
return crypto_uint8_y ^ crypto_uint8_z;
#endif
}
__attribute__((unused))
static inline
void crypto_uint8_minmax(crypto_uint8 *crypto_uint8_p,crypto_uint8 *crypto_uint8_q) {
crypto_uint8 crypto_uint8_x = *crypto_uint8_p;
crypto_uint8 crypto_uint8_y = *crypto_uint8_q;
#if defined(__GNUC__) && defined(__x86_64__)
uint32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_z32;
__asm__ ("cmpb %b2,%b1\n movl %1,%0\n cmoval %2,%1\n cmoval %0,%2" : "=&r"(crypto_uint8_z32), "+&q"(crypto_uint8_x32), "+q"(crypto_uint8_y32) : : "cc");
crypto_uint8_x = crypto_uint8_x32; crypto_uint8_y = crypto_uint8_y32;
*crypto_uint8_p = crypto_uint8_x;
*crypto_uint8_q = crypto_uint8_y;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_r, crypto_uint8_s;
__asm__ ("and %w0,%w0,255\n cmp %w0,%w3,uxtb\n csel %w1,%w0,%w3,lo\n csel %w2,%w3,%w0,lo" : "+&r"(crypto_uint8_x), "=&r"(crypto_uint8_r), "=r"(crypto_uint8_s) : "r"(crypto_uint8_y) : "cc");
*crypto_uint8_p = crypto_uint8_r;
*crypto_uint8_q = crypto_uint8_s;
#else
crypto_uint8 crypto_uint8_r = crypto_uint8_y ^ crypto_uint8_x;
crypto_uint8 crypto_uint8_z = crypto_uint8_y - crypto_uint8_x;
crypto_uint8_z ^= crypto_uint8_r & (crypto_uint8_z ^ crypto_uint8_y ^ (((crypto_uint8) 1) << (8-1)));
crypto_uint8_z = crypto_uint8_signed_negative_mask(crypto_uint8_z);
crypto_uint8_z &= crypto_uint8_r;
crypto_uint8_x ^= crypto_uint8_z;
crypto_uint8_y ^= crypto_uint8_z;
*crypto_uint8_p = crypto_uint8_x;
*crypto_uint8_q = crypto_uint8_y;
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_smaller_mask(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovbl %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n csetm %w0,lo" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
crypto_uint8 crypto_uint8_r = crypto_uint8_x ^ crypto_uint8_y;
crypto_uint8 crypto_uint8_z = crypto_uint8_x - crypto_uint8_y;
crypto_uint8_z ^= crypto_uint8_r & (crypto_uint8_z ^ crypto_uint8_x ^ (((crypto_uint8) 1) << (8-1)));
return crypto_uint8_signed_negative_mask(crypto_uint8_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_smaller_01(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovbl %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n cset %w0,lo" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
crypto_uint8 crypto_uint8_r = crypto_uint8_x ^ crypto_uint8_y;
crypto_uint8 crypto_uint8_z = crypto_uint8_x - crypto_uint8_y;
crypto_uint8_z ^= crypto_uint8_r & (crypto_uint8_z ^ crypto_uint8_x ^ (((crypto_uint8) 1) << (8-1)));
return crypto_uint8_topbit_01(crypto_uint8_z);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_leq_mask(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $-1,%1\n cmpb %b3,%b2\n cmovbel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n csetm %w0,ls" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
return ~crypto_uint8_smaller_mask(crypto_uint8_y,crypto_uint8_x);
#endif
}
__attribute__((unused))
static inline
crypto_uint8 crypto_uint8_leq_01(crypto_uint8 crypto_uint8_x,crypto_uint8 crypto_uint8_y) {
#if defined(__GNUC__) && defined(__x86_64__)
crypto_uint8 crypto_uint8_z;
int32_t crypto_uint8_x32 = crypto_uint8_x,crypto_uint8_y32 = crypto_uint8_y,crypto_uint8_q32,crypto_uint8_z32;
__asm__ ("xorl %0,%0\n movl $1,%1\n cmpb %b3,%b2\n cmovbel %1,%0" : "=&r"(crypto_uint8_z32), "=&r"(crypto_uint8_q32) : "q"(crypto_uint8_x32), "q"(crypto_uint8_y32) : "cc");
crypto_uint8_z = crypto_uint8_z32;
return crypto_uint8_z;
#elif defined(__GNUC__) && defined(__aarch64__)
crypto_uint8 crypto_uint8_z;
__asm__ ("and %w0,%w1,255\n cmp %w0,%w2,uxtb\n cset %w0,ls" : "=&r"(crypto_uint8_z) : "r"(crypto_uint8_x), "r"(crypto_uint8_y) : "cc");
return crypto_uint8_z;
#else
return 1-crypto_uint8_smaller_01(crypto_uint8_y,crypto_uint8_x);
#endif
}
__attribute__((unused))
static inline
int crypto_uint8_ones_num(crypto_uint8 crypto_uint8_x) {
crypto_uint8 crypto_uint8_y = crypto_uint8_x;
const crypto_uint8 C0 = 0x55;
const crypto_uint8 C1 = 0x33;
const crypto_uint8 C2 = 0x0f;
crypto_uint8_y -= ((crypto_uint8_y >> 1) & C0);
crypto_uint8_y = (crypto_uint8_y & C1) + ((crypto_uint8_y >> 2) & C1);
crypto_uint8_y = (crypto_uint8_y + (crypto_uint8_y >> 4)) & C2;
return crypto_uint8_y;
}
__attribute__((unused))
static inline
int crypto_uint8_bottomzeros_num(crypto_uint8 crypto_uint8_x) {
#if defined(__GNUC__) && defined(__x86_64__)
int32_t fallback = 8;
int32_t crypto_uint8_x32 = crypto_uint8_x;
__asm__ ("bsfl %0,%0\n cmovel %1,%0" : "+&r"(crypto_uint8_x32) : "r"(fallback) : "cc");
crypto_uint8_x = crypto_uint8_x32;
return crypto_uint8_x;
#elif defined(__GNUC__) && defined(__aarch64__)
int64_t crypto_uint8_y;
__asm__ ("orr %w0,%w1,-256\n rbit %w0,%w0\n clz %w0,%w0" : "=r"(crypto_uint8_y) : "r"(crypto_uint8_x) : );
return crypto_uint8_y;
#else
crypto_uint8 crypto_uint8_y = crypto_uint8_x ^ (crypto_uint8_x-1);
crypto_uint8_y = ((crypto_uint8_signed) crypto_uint8_y) >> 1;
crypto_uint8_y &= ~(crypto_uint8_x & (((crypto_uint8) 1) << (8-1)));
return crypto_uint8_ones_num(crypto_uint8_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/crypto_uintN.h 0000664 0000000 0000000 00000135507 14745512304 0020377 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#ifndef crypto_uintN_h
#define crypto_uintN_h
#include
#define crypto_uintN uintN_t
#define crypto_uintN_signed intN_t
#define crypto_uintN_signed_optblocker namespace_uintN_signed_optblocker
extern volatile crypto_uintN_signed crypto_uintN_signed_optblocker;
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_load(const unsigned char *crypto_uintN_s) {
crypto_uintN crypto_uintN_z = 0;
int crypto_uintN_k;
for (crypto_uintN_k = 0;crypto_uintN_k < N;crypto_uintN_k += 8)
crypto_uintN_z |= ((crypto_uintN) (*crypto_uintN_s++)) << crypto_uintN_k;
return crypto_uintN_z;
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_load_bigendian(const unsigned char *crypto_uintN_s) {
crypto_uintN crypto_uintN_z = 0;
int crypto_uintN_k;
for (crypto_uintN_k = N - 8;crypto_uintN_k >= 0;crypto_uintN_k -= 8)
crypto_uintN_z |= ((crypto_uintN) (*crypto_uintN_s++)) << crypto_uintN_k;
return crypto_uintN_z;
}
__attribute__((unused))
static inline
void crypto_uintN_store(unsigned char *crypto_uintN_s,crypto_uintN crypto_uintN_x) {
int crypto_uintN_k;
for (crypto_uintN_k = 0;crypto_uintN_k < N;crypto_uintN_k += 8)
*crypto_uintN_s++ = crypto_uintN_x >> crypto_uintN_k;
}
__attribute__((unused))
static inline
void crypto_uintN_store_bigendian(unsigned char *crypto_uintN_s,crypto_uintN crypto_uintN_x) {
int crypto_uintN_k;
for (crypto_uintN_k = N - 8;crypto_uintN_k >= 0;crypto_uintN_k -= 8)
*crypto_uintN_s++ = crypto_uintN_x >> crypto_uintN_k;
}
__attribute__((unused))
static inline
crypto_uintN_signed crypto_uintN_signed_negative_mask(crypto_uintN_signed crypto_uintN_x) {
#if amd64
8: readasm("amd64; int8 crypto_uintN_x; crypto_uintN_x signed>>= 7");
16: readasm("amd64; int16 crypto_uintN_x; crypto_uintN_x signed>>= 15");
32: readasm("amd64; int32 crypto_uintN_x; crypto_uintN_x signed>>= 31");
64: readasm("amd64; int64 crypto_uintN_x; crypto_uintN_x signed>>= 63");
return crypto_uintN_x;
#elif arm64
crypto_uintN_signed crypto_uintN_y;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = -(1 & (crypto_uintN_x unsigned>> 7))");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = -(1 & (crypto_uintN_x unsigned>> 15))");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = crypto_uintN_x signed>> 31");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = crypto_uintN_x signed>> 63");
return crypto_uintN_y;
#else
crypto_uintN_x >>= N-6;
crypto_uintN_x += crypto_uintN_signed_optblocker;
crypto_uintN_x >>= 5;
return crypto_uintN_x;
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_topbit_01(crypto_uintN crypto_uintN_x) {
#if amd64
8: readasm("amd64; int8 crypto_uintN_x; crypto_uintN_x unsigned>>= 7");
16: readasm("amd64; int16 crypto_uintN_x; crypto_uintN_x unsigned>>= 15");
32: readasm("amd64; int32 crypto_uintN_x; crypto_uintN_x unsigned>>= 31");
64: readasm("amd64; int64 crypto_uintN_x; crypto_uintN_x unsigned>>= 63");
return crypto_uintN_x;
#elif arm64
crypto_uintN_signed crypto_uintN_y;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = 1 & (crypto_uintN_x unsigned>> 7)");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = 1 & (crypto_uintN_x unsigned>> 15)");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = crypto_uintN_x unsigned>> 31");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = crypto_uintN_x unsigned>> 63");
return crypto_uintN_y;
#else
crypto_uintN_x >>= N-6;
crypto_uintN_x += crypto_uintN_signed_optblocker;
crypto_uintN_x >>= 5;
return crypto_uintN_x;
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_topbit_mask(crypto_uintN crypto_uintN_x) {
return crypto_uintN_signed_negative_mask(crypto_uintN_x);
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_bottombit_mask(crypto_uintN crypto_uintN_x) {
#if amd64
8: readasm("amd64; int8 crypto_uintN_x; crypto_uintN_x &= 1");
16: readasm("amd64; int16 crypto_uintN_x; crypto_uintN_x &= 1");
32: readasm("amd64; int32 crypto_uintN_x; crypto_uintN_x &= 1");
64: readasm("amd64; int64 crypto_uintN_x; crypto_uintN_x &= 1");
return -crypto_uintN_x;
#elif arm64
crypto_uintN crypto_uintN_y;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = -(1 & (crypto_uintN_x unsigned>> 0))");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = -(1 & (crypto_uintN_x unsigned>> 0))");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = -(1 & (crypto_uintN_x unsigned>> 0))");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = -(1 & (crypto_uintN_x unsigned>> 0))");
return crypto_uintN_y;
#else
crypto_uintN_x &= 1 + crypto_uintN_signed_optblocker;
return -crypto_uintN_x;
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_bottombit_01(crypto_uintN crypto_uintN_x) {
#if amd64
8: readasm("amd64; int8 crypto_uintN_x; crypto_uintN_x &= 1");
16: readasm("amd64; int16 crypto_uintN_x; crypto_uintN_x &= 1");
32: readasm("amd64; int32 crypto_uintN_x; crypto_uintN_x &= 1");
64: readasm("amd64; int64 crypto_uintN_x; crypto_uintN_x &= 1");
return crypto_uintN_x;
#elif arm64
crypto_uintN crypto_uintN_y;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = 1 & (crypto_uintN_x unsigned>> 0)");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = 1 & (crypto_uintN_x unsigned>> 0)");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = 1 & (crypto_uintN_x unsigned>> 0)");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = 1 & (crypto_uintN_x unsigned>> 0)");
return crypto_uintN_y;
#else
crypto_uintN_x &= 1 + crypto_uintN_signed_optblocker;
return crypto_uintN_x;
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_bitinrangepublicpos_mask(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_s) {
#if amd64
8: readasm("amd64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
#elif arm64
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
#else
crypto_uintN_x >>= crypto_uintN_s ^ crypto_uintN_signed_optblocker;
#endif
return crypto_uintN_bottombit_mask(crypto_uintN_x);
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_bitinrangepublicpos_01(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_s) {
#if amd64
8: readasm("amd64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
#elif arm64
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
#else
crypto_uintN_x >>= crypto_uintN_s ^ crypto_uintN_signed_optblocker;
#endif
return crypto_uintN_bottombit_01(crypto_uintN_x);
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_shlmod(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_s) {
#if amd64
8: crypto_uintN_s &= 7;
8: readasm("amd64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_x <<= crypto_uintN_s");
16: crypto_uintN_s &= 15;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_x <<= crypto_uintN_s");
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x <<= crypto_uintN_s");
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x <<= crypto_uintN_s");
#elif arm64
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_s = crypto_uintN_s & 7; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x << crypto_uintN_s");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_s = crypto_uintN_s & 15; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x << crypto_uintN_s");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x << crypto_uintN_s");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x << crypto_uintN_s");
#else
int crypto_uintN_k, crypto_uintN_l;
for (crypto_uintN_l = 0,crypto_uintN_k = 1;crypto_uintN_k < N;++crypto_uintN_l,crypto_uintN_k *= 2)
crypto_uintN_x ^= (crypto_uintN_x ^ (crypto_uintN_x << crypto_uintN_k)) & crypto_uintN_bitinrangepublicpos_mask(crypto_uintN_s,crypto_uintN_l);
#endif
return crypto_uintN_x;
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_shrmod(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_s) {
#if amd64
8: crypto_uintN_s &= 7;
8: readasm("amd64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
16: crypto_uintN_s &= 15;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x unsigned>>= crypto_uintN_s");
#elif arm64
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_s; crypto_uintN_s = crypto_uintN_s & 7; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_s; crypto_uintN_s = crypto_uintN_s & 15; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_s; crypto_uintN_x = crypto_uintN_x unsigned>> crypto_uintN_s");
#else
int crypto_uintN_k, crypto_uintN_l;
for (crypto_uintN_l = 0,crypto_uintN_k = 1;crypto_uintN_k < N;++crypto_uintN_l,crypto_uintN_k *= 2)
crypto_uintN_x ^= (crypto_uintN_x ^ (crypto_uintN_x >> crypto_uintN_k)) & crypto_uintN_bitinrangepublicpos_mask(crypto_uintN_s,crypto_uintN_l);
#endif
return crypto_uintN_x;
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_bitmod_mask(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_s) {
crypto_uintN_x = crypto_uintN_shrmod(crypto_uintN_x,crypto_uintN_s);
return crypto_uintN_bottombit_mask(crypto_uintN_x);
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_bitmod_01(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_s) {
crypto_uintN_x = crypto_uintN_shrmod(crypto_uintN_x,crypto_uintN_s);
return crypto_uintN_bottombit_01(crypto_uintN_x);
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_nonzero_mask(crypto_uintN crypto_uintN_x) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = -1; crypto_uintN_x32 & (int8) crypto_uintN_x32; crypto_uintN_z32 = crypto_uintN_q32 if !=");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if !=");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if !=");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if !=");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 255; crypto_uintN_z = -1 if != else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 65535; crypto_uintN_z = -1 if != else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = -1 if != else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = -1 if != else 0");
return crypto_uintN_z;
#else
crypto_uintN_x |= -crypto_uintN_x;
return crypto_uintN_signed_negative_mask(crypto_uintN_x);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_nonzero_01(crypto_uintN crypto_uintN_x) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = 1; crypto_uintN_x32 & (int8) crypto_uintN_x32; crypto_uintN_z32 = crypto_uintN_q32 if !=");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if !=");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if !=");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if !=");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 255; crypto_uintN_z = 1 if != else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 65535; crypto_uintN_z = 1 if != else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = 1 if != else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = 1 if != else 0");
return crypto_uintN_z;
#else
crypto_uintN_x |= -crypto_uintN_x;
return crypto_uintN_topbit_01(crypto_uintN_x);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_zero_mask(crypto_uintN crypto_uintN_x) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = -1; crypto_uintN_x32 & (int8) crypto_uintN_x32; crypto_uintN_z32 = crypto_uintN_q32 if =");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if =");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if =");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if =");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 255; crypto_uintN_z = -1 if = else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 65535; crypto_uintN_z = -1 if = else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = -1 if = else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = -1 if = else 0");
return crypto_uintN_z;
#else
return ~crypto_uintN_nonzero_mask(crypto_uintN_x);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_zero_01(crypto_uintN crypto_uintN_x) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = 1; crypto_uintN_x32 & (int8) crypto_uintN_x32; crypto_uintN_z32 = crypto_uintN_q32 if =");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if =");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if =");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x & crypto_uintN_x; crypto_uintN_z = crypto_uintN_q if =");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 255; crypto_uintN_z = 1 if = else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_z; crypto_uintN_x & 65535; crypto_uintN_z = 1 if = else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = 1 if = else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_z; crypto_uintN_x - 0; crypto_uintN_z = 1 if = else 0");
return crypto_uintN_z;
#else
return 1-crypto_uintN_nonzero_01(crypto_uintN_x);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_unequal_mask(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = -1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if !=");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if !=");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if !=");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if !=");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = -1 if != else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = -1 if != else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if != else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if != else 0");
return crypto_uintN_z;
#else
return crypto_uintN_nonzero_mask(crypto_uintN_x ^ crypto_uintN_y);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_unequal_01(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = 1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if !=");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if !=");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if !=");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if !=");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = 1 if != else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = 1 if != else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if != else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if != else 0");
return crypto_uintN_z;
#else
return crypto_uintN_nonzero_01(crypto_uintN_x ^ crypto_uintN_y);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_equal_mask(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = -1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if =");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if =");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if =");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if =");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = -1 if = else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = -1 if = else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if = else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if = else 0");
return crypto_uintN_z;
#else
return ~crypto_uintN_unequal_mask(crypto_uintN_x,crypto_uintN_y);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_equal_01(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = 1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if =");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if =");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if =");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if =");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = 1 if = else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = 1 if = else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if = else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if = else 0");
return crypto_uintN_z;
#else
return 1-crypto_uintN_unequal_01(crypto_uintN_x,crypto_uintN_y);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_min(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: uint32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_y32; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_x32 = crypto_uintN_y32 if unsigned>");
8: crypto_uintN_x = crypto_uintN_x32;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned>");
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned>");
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned>");
return crypto_uintN_x;
#elif arm64
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x - (uint8) crypto_uintN_y; crypto_uintN_x = crypto_uintN_x if unsigned< else crypto_uintN_y");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x - (uint16) crypto_uintN_y; crypto_uintN_x = crypto_uintN_x if unsigned< else crypto_uintN_y");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_x if unsigned< else crypto_uintN_y");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_x if unsigned< else crypto_uintN_y");
return crypto_uintN_x;
#else
crypto_uintN crypto_uintN_r = crypto_uintN_y ^ crypto_uintN_x;
crypto_uintN crypto_uintN_z = crypto_uintN_y - crypto_uintN_x;
crypto_uintN_z ^= crypto_uintN_r & (crypto_uintN_z ^ crypto_uintN_y ^ (((crypto_uintN) 1) << (N-1)));
crypto_uintN_z = crypto_uintN_signed_negative_mask(crypto_uintN_z);
crypto_uintN_z &= crypto_uintN_r;
return crypto_uintN_x ^ crypto_uintN_z;
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_max(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: uint32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_y32; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_x32 = crypto_uintN_y32 if unsigned<");
8: crypto_uintN_x = crypto_uintN_x32;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned<");
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned<");
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned<");
return crypto_uintN_x;
#elif arm64
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x - (uint8) crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned< else crypto_uintN_x");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x - (uint16) crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned< else crypto_uintN_x");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned< else crypto_uintN_x");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_x - crypto_uintN_y; crypto_uintN_x = crypto_uintN_y if unsigned< else crypto_uintN_x");
return crypto_uintN_x;
#else
crypto_uintN crypto_uintN_r = crypto_uintN_y ^ crypto_uintN_x;
crypto_uintN crypto_uintN_z = crypto_uintN_y - crypto_uintN_x;
crypto_uintN_z ^= crypto_uintN_r & (crypto_uintN_z ^ crypto_uintN_y ^ (((crypto_uintN) 1) << (N-1)));
crypto_uintN_z = crypto_uintN_signed_negative_mask(crypto_uintN_z);
crypto_uintN_z &= crypto_uintN_r;
return crypto_uintN_y ^ crypto_uintN_z;
#endif
}
__attribute__((unused))
static inline
void crypto_uintN_minmax(crypto_uintN *crypto_uintN_p,crypto_uintN *crypto_uintN_q) {
crypto_uintN crypto_uintN_x = *crypto_uintN_p;
crypto_uintN crypto_uintN_y = *crypto_uintN_q;
#if amd64
8: uint32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_x32; crypto_uintN_x32 = crypto_uintN_y32 if unsigned>; crypto_uintN_y32 = crypto_uintN_z32 if unsigned>");
8: crypto_uintN_x = crypto_uintN_x32; crypto_uintN_y = crypto_uintN_y32;
16: crypto_uintN crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_x; crypto_uintN_x = crypto_uintN_y if unsigned>; crypto_uintN_y = crypto_uintN_z if unsigned>");
32: crypto_uintN crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_x; crypto_uintN_x = crypto_uintN_y if unsigned>; crypto_uintN_y = crypto_uintN_z if unsigned>");
64: crypto_uintN crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_x; crypto_uintN_x = crypto_uintN_y if unsigned>; crypto_uintN_y = crypto_uintN_z if unsigned>");
*crypto_uintN_p = crypto_uintN_x;
*crypto_uintN_q = crypto_uintN_y;
#elif arm64
crypto_uintN crypto_uintN_r, crypto_uintN_s;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_r crypto_uintN_s; crypto_uintN_x = (uint8) crypto_uintN_x; crypto_uintN_x - (uint8) crypto_uintN_y; crypto_uintN_r = crypto_uintN_x if unsigned< else crypto_uintN_y; crypto_uintN_s = crypto_uintN_y if unsigned< else crypto_uintN_x");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_r crypto_uintN_s; crypto_uintN_x = (uint16) crypto_uintN_x; crypto_uintN_x - (uint16) crypto_uintN_y; crypto_uintN_r = crypto_uintN_x if unsigned< else crypto_uintN_y; crypto_uintN_s = crypto_uintN_y if unsigned< else crypto_uintN_x");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_r crypto_uintN_s; crypto_uintN_x - crypto_uintN_y; crypto_uintN_r = crypto_uintN_x if unsigned< else crypto_uintN_y; crypto_uintN_s = crypto_uintN_y if unsigned< else crypto_uintN_x");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_r crypto_uintN_s; crypto_uintN_x - crypto_uintN_y; crypto_uintN_r = crypto_uintN_x if unsigned< else crypto_uintN_y; crypto_uintN_s = crypto_uintN_y if unsigned< else crypto_uintN_x");
*crypto_uintN_p = crypto_uintN_r;
*crypto_uintN_q = crypto_uintN_s;
#else
crypto_uintN crypto_uintN_r = crypto_uintN_y ^ crypto_uintN_x;
crypto_uintN crypto_uintN_z = crypto_uintN_y - crypto_uintN_x;
crypto_uintN_z ^= crypto_uintN_r & (crypto_uintN_z ^ crypto_uintN_y ^ (((crypto_uintN) 1) << (N-1)));
crypto_uintN_z = crypto_uintN_signed_negative_mask(crypto_uintN_z);
crypto_uintN_z &= crypto_uintN_r;
crypto_uintN_x ^= crypto_uintN_z;
crypto_uintN_y ^= crypto_uintN_z;
*crypto_uintN_p = crypto_uintN_x;
*crypto_uintN_q = crypto_uintN_y;
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_smaller_mask(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = -1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if unsigned<");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = -1 if unsigned< else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = -1 if unsigned< else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if unsigned< else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if unsigned< else 0");
return crypto_uintN_z;
#else
crypto_uintN crypto_uintN_r = crypto_uintN_x ^ crypto_uintN_y;
crypto_uintN crypto_uintN_z = crypto_uintN_x - crypto_uintN_y;
crypto_uintN_z ^= crypto_uintN_r & (crypto_uintN_z ^ crypto_uintN_x ^ (((crypto_uintN) 1) << (N-1)));
return crypto_uintN_signed_negative_mask(crypto_uintN_z);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_smaller_01(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = 1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if unsigned<");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = 1 if unsigned< else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = 1 if unsigned< else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if unsigned< else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if unsigned< else 0");
return crypto_uintN_z;
#else
crypto_uintN crypto_uintN_r = crypto_uintN_x ^ crypto_uintN_y;
crypto_uintN crypto_uintN_z = crypto_uintN_x - crypto_uintN_y;
crypto_uintN_z ^= crypto_uintN_r & (crypto_uintN_z ^ crypto_uintN_x ^ (((crypto_uintN) 1) << (N-1)));
return crypto_uintN_topbit_01(crypto_uintN_z);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_leq_mask(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = -1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if unsigned<=");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<=");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<=");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = -1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<=");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = -1 if unsigned<= else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = -1 if unsigned<= else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if unsigned<= else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = -1 if unsigned<= else 0");
return crypto_uintN_z;
#else
return ~crypto_uintN_smaller_mask(crypto_uintN_y,crypto_uintN_x);
#endif
}
__attribute__((unused))
static inline
crypto_uintN crypto_uintN_leq_01(crypto_uintN crypto_uintN_x,crypto_uintN crypto_uintN_y) {
#if amd64
8: crypto_uintN crypto_uintN_z;
8: int32_t crypto_uintN_x32 = crypto_uintN_x,crypto_uintN_y32 = crypto_uintN_y,crypto_uintN_q32,crypto_uintN_z32;
8: readasm("amd64; int32 crypto_uintN_x32 crypto_uintN_q32 crypto_uintN_y32 crypto_uintN_z32; crypto_uintN_z32 = 0; crypto_uintN_q32 = 1; crypto_uintN_x32 - (int8) crypto_uintN_y32; crypto_uintN_z32 = crypto_uintN_q32 if unsigned<=");
8: crypto_uintN_z = crypto_uintN_z32;
16: crypto_uintN crypto_uintN_q,crypto_uintN_z;
16: readasm("amd64; int16 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<=");
32: crypto_uintN crypto_uintN_q,crypto_uintN_z;
32: readasm("amd64; int32 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<=");
64: crypto_uintN crypto_uintN_q,crypto_uintN_z;
64: readasm("amd64; int64 crypto_uintN_x crypto_uintN_q crypto_uintN_y crypto_uintN_z; crypto_uintN_z = 0; crypto_uintN_q = 1; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = crypto_uintN_q if unsigned<=");
return crypto_uintN_z;
#elif arm64
crypto_uintN crypto_uintN_z;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint8) crypto_uintN_x; crypto_uintN_z - (uint8) crypto_uintN_y; crypto_uintN_z = 1 if unsigned<= else 0");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_z = (uint16) crypto_uintN_x; crypto_uintN_z - (uint16) crypto_uintN_y; crypto_uintN_z = 1 if unsigned<= else 0");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if unsigned<= else 0");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y crypto_uintN_z; crypto_uintN_x - crypto_uintN_y; crypto_uintN_z = 1 if unsigned<= else 0");
return crypto_uintN_z;
#else
return 1-crypto_uintN_smaller_01(crypto_uintN_y,crypto_uintN_x);
#endif
}
__attribute__((unused))
static inline
int crypto_uintN_ones_num(crypto_uintN crypto_uintN_x) {
crypto_uintN crypto_uintN_y = crypto_uintN_x;
8: const crypto_uintN C0 = 0x55;
16: const crypto_uintN C0 = 0x5555;
32: const crypto_uintN C0 = 0x55555555;
64: const crypto_uintN C0 = 0x5555555555555555;
8: const crypto_uintN C1 = 0x33;
16: const crypto_uintN C1 = 0x3333;
32: const crypto_uintN C1 = 0x33333333;
64: const crypto_uintN C1 = 0x3333333333333333;
8: const crypto_uintN C2 = 0x0f;
16: const crypto_uintN C2 = 0x0f0f;
32: const crypto_uintN C2 = 0x0f0f0f0f;
64: const crypto_uintN C2 = 0x0f0f0f0f0f0f0f0f;
crypto_uintN_y -= ((crypto_uintN_y >> 1) & C0);
crypto_uintN_y = (crypto_uintN_y & C1) + ((crypto_uintN_y >> 2) & C1);
crypto_uintN_y = (crypto_uintN_y + (crypto_uintN_y >> 4)) & C2;
16: crypto_uintN_y = (crypto_uintN_y + (crypto_uintN_y >> 8)) & 0xff;
32: crypto_uintN_y += crypto_uintN_y >> 8;
32: crypto_uintN_y = (crypto_uintN_y + (crypto_uintN_y >> 16)) & 0xff;
64: crypto_uintN_y += crypto_uintN_y >> 8;
64: crypto_uintN_y += crypto_uintN_y >> 16;
64: crypto_uintN_y = (crypto_uintN_y + (crypto_uintN_y >> 32)) & 0xff;
return crypto_uintN_y;
}
__attribute__((unused))
static inline
int crypto_uintN_bottomzeros_num(crypto_uintN crypto_uintN_x) {
#if amd64
8: int32_t fallback = N;
8: int32_t crypto_uintN_x32 = crypto_uintN_x;
8: readasm("amd64; int32 crypto_uintN_x32 fallback; crypto_uintN_x32 = numbottomzeros_tricky crypto_uintN_x32; crypto_uintN_x32 = fallback if =");
8: crypto_uintN_x = crypto_uintN_x32;
16: crypto_uintN fallback = N;
16: readasm("amd64; int16 crypto_uintN_x fallback; crypto_uintN_x = numbottomzeros_tricky crypto_uintN_x; crypto_uintN_x = fallback if =");
32: crypto_uintN fallback = N;
32: readasm("amd64; int32 crypto_uintN_x fallback; crypto_uintN_x = numbottomzeros_tricky crypto_uintN_x; crypto_uintN_x = fallback if =");
64: crypto_uintN fallback = N;
64: readasm("amd64; int64 crypto_uintN_x fallback; crypto_uintN_x = numbottomzeros_tricky crypto_uintN_x; crypto_uintN_x = fallback if =");
return crypto_uintN_x;
#elif arm64
int64_t crypto_uintN_y;
8: readasm("arm64; int8 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = crypto_uintN_x | -256; crypto_uintN_y = bitrev32 crypto_uintN_y; crypto_uintN_y = numbottomzeros crypto_uintN_y");
16: readasm("arm64; int16 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = crypto_uintN_x | -65536; crypto_uintN_y = bitrev32 crypto_uintN_y; crypto_uintN_y = numbottomzeros crypto_uintN_y");
32: readasm("arm64; int32 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = bitrev32 crypto_uintN_x; crypto_uintN_y = numbottomzeros crypto_uintN_y");
64: readasm("arm64; int64 crypto_uintN_x crypto_uintN_y; crypto_uintN_y = bitrev64 crypto_uintN_x; crypto_uintN_y = numbottomzeros crypto_uintN_y");
return crypto_uintN_y;
#else
crypto_uintN crypto_uintN_y = crypto_uintN_x ^ (crypto_uintN_x-1);
crypto_uintN_y = ((crypto_uintN_signed) crypto_uintN_y) >> 1;
crypto_uintN_y &= ~(crypto_uintN_x & (((crypto_uintN) 1) << (N-1)));
return crypto_uintN_ones_num(crypto_uintN_y);
#endif
}
#endif
tinyssh-20250126/cryptoint/functions 0000664 0000000 0000000 00000077342 14745512304 0017466 0 ustar 00root root 0000000 0000000 TYPE TYPE_load(const unsigned char *S) {
TYPE Z = 0;
int K;
for (K = 0;K < N;K += 8)
Z |= ((TYPE) (*S++)) << K;
return Z;
}
TYPE TYPE_load_bigendian(const unsigned char *S) {
TYPE Z = 0;
int K;
for (K = N - 8;K >= 0;K -= 8)
Z |= ((TYPE) (*S++)) << K;
return Z;
}
void TYPE_store(unsigned char *S,TYPE X) {
int K;
for (K = 0;K < N;K += 8)
*S++ = X >> K;
}
void TYPE_store_bigendian(unsigned char *S,TYPE X) {
int K;
for (K = N - 8;K >= 0;K -= 8)
*S++ = X >> K;
}
# could instead use X >>= (N-1) ^ SIGNED_optblocker
SIGNED SIGNED_negative_mask(SIGNED X) {
#if amd64
8: readasm("amd64; int8 X; X signed>>= 7");
16: readasm("amd64; int16 X; X signed>>= 15");
32: readasm("amd64; int32 X; X signed>>= 31");
64: readasm("amd64; int64 X; X signed>>= 63");
return X;
#elif arm64
SIGNED Y;
8: readasm("arm64; int8 X Y; Y = -(1 & (X unsigned>> 7))");
16: readasm("arm64; int16 X Y; Y = -(1 & (X unsigned>> 15))");
32: readasm("arm64; int32 X Y; Y = X signed>> 31");
64: readasm("arm64; int64 X Y; Y = X signed>> 63");
return Y;
#else
X >>= N-6;
X += SIGNED_optblocker;
X >>= 5;
return X;
#endif
}
UNSIGNED UNSIGNED_topbit_01(UNSIGNED X) {
#if amd64
8: readasm("amd64; int8 X; X unsigned>>= 7");
16: readasm("amd64; int16 X; X unsigned>>= 15");
32: readasm("amd64; int32 X; X unsigned>>= 31");
64: readasm("amd64; int64 X; X unsigned>>= 63");
return X;
#elif arm64
SIGNED Y;
8: readasm("arm64; int8 X Y; Y = 1 & (X unsigned>> 7)");
16: readasm("arm64; int16 X Y; Y = 1 & (X unsigned>> 15)");
32: readasm("arm64; int32 X Y; Y = X unsigned>> 31");
64: readasm("arm64; int64 X Y; Y = X unsigned>> 63");
return Y;
#else
X >>= N-6;
X += SIGNED_optblocker;
X >>= 5;
return X;
#endif
}
SIGNED:
TYPE TYPE_negative_01(TYPE X) {
return UNSIGNED_topbit_01(X);
}
SIGNED:
TYPE TYPE_topbit_mask(TYPE X) {
return SIGNED_negative_mask(X);
}
SIGNED:
TYPE TYPE_topbit_01(TYPE X) {
return UNSIGNED_topbit_01(X);
}
UNSIGNED:
TYPE TYPE_topbit_mask(TYPE X) {
return SIGNED_negative_mask(X);
}
TYPE TYPE_bottombit_mask(TYPE X) {
#if amd64
8: readasm("amd64; int8 X; X &= 1");
16: readasm("amd64; int16 X; X &= 1");
32: readasm("amd64; int32 X; X &= 1");
64: readasm("amd64; int64 X; X &= 1");
return -X;
#elif arm64
TYPE Y;
8: readasm("arm64; int8 X Y; Y = -(1 & (X unsigned>> 0))");
16: readasm("arm64; int16 X Y; Y = -(1 & (X unsigned>> 0))");
32: readasm("arm64; int32 X Y; Y = -(1 & (X unsigned>> 0))");
64: readasm("arm64; int64 X Y; Y = -(1 & (X unsigned>> 0))");
return Y;
#else
X &= 1 + SIGNED_optblocker;
return -X;
#endif
}
TYPE TYPE_bottombit_01(TYPE X) {
#if amd64
8: readasm("amd64; int8 X; X &= 1");
16: readasm("amd64; int16 X; X &= 1");
32: readasm("amd64; int32 X; X &= 1");
64: readasm("amd64; int64 X; X &= 1");
return X;
#elif arm64
TYPE Y;
8: readasm("arm64; int8 X Y; Y = 1 & (X unsigned>> 0)");
16: readasm("arm64; int16 X Y; Y = 1 & (X unsigned>> 0)");
32: readasm("arm64; int32 X Y; Y = 1 & (X unsigned>> 0)");
64: readasm("arm64; int64 X Y; Y = 1 & (X unsigned>> 0)");
return Y;
#else
X &= 1 + SIGNED_optblocker;
return X;
#endif
}
# without optblocker here, seems possible that compiler will cause trouble,
# especially if S is compile-time constant N-1
SIGNED:
TYPE TYPE_bitinrangepublicpos_mask(TYPE X,TYPE S) {
#if amd64
8: readasm("amd64; int8 X S; X signed>>= S");
16: readasm("amd64; int16 X S; X signed>>= S");
32: readasm("amd64; int32 X S; X signed>>= S");
64: readasm("amd64; int64 X S; X signed>>= S");
#elif arm64
8: readasm("arm64; int8 X S; X = (int8) X; X = X signed>> S");
16: readasm("arm64; int16 X S; X = (int16) X; X = X signed>> S");
32: readasm("arm64; int32 X S; X = X signed>> S");
64: readasm("arm64; int64 X S; X = X signed>> S");
#else
X >>= S ^ SIGNED_optblocker;
#endif
return TYPE_bottombit_mask(X);
}
# without optblocker here, seems possible that compiler will cause trouble,
# especially if S is compile-time constant N-1
SIGNED:
TYPE TYPE_bitinrangepublicpos_01(TYPE X,TYPE S) {
#if amd64
8: readasm("amd64; int8 X S; X signed>>= S");
16: readasm("amd64; int16 X S; X signed>>= S");
32: readasm("amd64; int32 X S; X signed>>= S");
64: readasm("amd64; int64 X S; X signed>>= S");
#elif arm64
8: readasm("arm64; int8 X S; X = (int8) X; X = X signed>> S");
16: readasm("arm64; int16 X S; X = (int16) X; X = X signed>> S");
32: readasm("arm64; int32 X S; X = X signed>> S");
64: readasm("arm64; int64 X S; X = X signed>> S");
#else
X >>= S ^ SIGNED_optblocker;
#endif
return TYPE_bottombit_01(X);
}
# without optblocker here, seems possible that compiler will cause trouble,
# especially if S is compile-time constant N-1
UNSIGNED:
TYPE TYPE_bitinrangepublicpos_mask(TYPE X,TYPE S) {
#if amd64
8: readasm("amd64; int8 X S; X unsigned>>= S");
16: readasm("amd64; int16 X S; X unsigned>>= S");
32: readasm("amd64; int32 X S; X unsigned>>= S");
64: readasm("amd64; int64 X S; X unsigned>>= S");
#elif arm64
8: readasm("arm64; int8 X S; X = (uint8) X; X = X unsigned>> S");
16: readasm("arm64; int16 X S; X = (uint16) X; X = X unsigned>> S");
32: readasm("arm64; int32 X S; X = X unsigned>> S");
64: readasm("arm64; int64 X S; X = X unsigned>> S");
#else
X >>= S ^ SIGNED_optblocker;
#endif
return TYPE_bottombit_mask(X);
}
# without optblocker here, seems possible that compiler will cause trouble,
# especially if S is compile-time constant N-1
UNSIGNED:
TYPE TYPE_bitinrangepublicpos_01(TYPE X,TYPE S) {
#if amd64
8: readasm("amd64; int8 X S; X unsigned>>= S");
16: readasm("amd64; int16 X S; X unsigned>>= S");
32: readasm("amd64; int32 X S; X unsigned>>= S");
64: readasm("amd64; int64 X S; X unsigned>>= S");
#elif arm64
8: readasm("arm64; int8 X S; X = (uint8) X; X = X unsigned>> S");
16: readasm("arm64; int16 X S; X = (uint16) X; X = X unsigned>> S");
32: readasm("arm64; int32 X S; X = X unsigned>> S");
64: readasm("arm64; int64 X S; X = X unsigned>> S");
#else
X >>= S ^ SIGNED_optblocker;
#endif
return TYPE_bottombit_01(X);
}
# same as (X << (S % N)) but without assuming barrel shifter
# for amd64, assumes constant-time barrel shifter
TYPE TYPE_shlmod(TYPE X,TYPE S) {
#if amd64
8: S &= 7;
8: readasm("amd64; int8 X S; X <<= S");
16: S &= 15;
16: readasm("amd64; int16 X S; X <<= S");
32: readasm("amd64; int32 X S; X <<= S");
64: readasm("amd64; int64 X S; X <<= S");
#elif arm64
8: readasm("arm64; int8 X S; S = S & 7; X = (uint8) X; X = X << S");
16: readasm("arm64; int16 X S; S = S & 15; X = (uint16) X; X = X << S");
32: readasm("arm64; int32 X S; X = X << S");
64: readasm("arm64; int64 X S; X = X << S");
#else
int K, L;
for (L = 0,K = 1;K < N;++L,K *= 2)
X ^= (X ^ (X << K)) & TYPE_bitinrangepublicpos_mask(S,L);
#endif
return X;
}
# same as (X >> (S % N)) but without assuming barrel shifter
SIGNED:
TYPE TYPE_shrmod(TYPE X,TYPE S) {
#if amd64
8: S &= 7;
8: readasm("amd64; int8 X S; X signed>>= S");
16: S &= 15;
16: readasm("amd64; int16 X S; X signed>>= S");
32: readasm("amd64; int32 X S; X signed>>= S");
64: readasm("amd64; int64 X S; X signed>>= S");
#elif arm64
8: readasm("arm64; int8 X S; S = S & 7; X = (int8) X; X = X signed>> S");
16: readasm("arm64; int16 X S; S = S & 15; X = (int16) X; X = X signed>> S");
32: readasm("arm64; int32 X S; X = X signed>> S");
64: readasm("arm64; int64 X S; X = X signed>> S");
#else
int K, L;
for (L = 0,K = 1;K < N;++L,K *= 2)
X ^= (X ^ (X >> K)) & TYPE_bitinrangepublicpos_mask(S,L);
#endif
return X;
}
# same as (X >> (S % N)) but without assuming barrel shifter
UNSIGNED:
TYPE TYPE_shrmod(TYPE X,TYPE S) {
#if amd64
8: S &= 7;
8: readasm("amd64; int8 X S; X unsigned>>= S");
16: S &= 15;
16: readasm("amd64; int16 X S; X unsigned>>= S");
32: readasm("amd64; int32 X S; X unsigned>>= S");
64: readasm("amd64; int64 X S; X unsigned>>= S");
#elif arm64
8: readasm("arm64; int8 X S; S = S & 7; X = (uint8) X; X = X unsigned>> S");
16: readasm("arm64; int16 X S; S = S & 15; X = (uint16) X; X = X unsigned>> S");
32: readasm("arm64; int32 X S; X = X unsigned>> S");
64: readasm("arm64; int64 X S; X = X unsigned>> S");
#else
int K, L;
for (L = 0,K = 1;K < N;++L,K *= 2)
X ^= (X ^ (X >> K)) & TYPE_bitinrangepublicpos_mask(S,L);
#endif
return X;
}
TYPE TYPE_bitmod_mask(TYPE X,TYPE S) {
X = TYPE_shrmod(X,S);
return TYPE_bottombit_mask(X);
}
TYPE TYPE_bitmod_01(TYPE X,TYPE S) {
X = TYPE_shrmod(X,S);
return TYPE_bottombit_01(X);
}
TYPE TYPE_nonzero_mask(TYPE X) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Z32; Z32 = 0; Q32 = -1; X32 & (int8) X32; Z32 = Q32 if !=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Z; Z = 0; Q = -1; X & X; Z = Q if !=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Z; Z = 0; Q = -1; X & X; Z = Q if !=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Z; Z = 0; Q = -1; X & X; Z = Q if !=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Z; X & 255; Z = -1 if != else 0");
16: readasm("arm64; int16 X Z; X & 65535; Z = -1 if != else 0");
32: readasm("arm64; int32 X Z; X - 0; Z = -1 if != else 0");
64: readasm("arm64; int64 X Z; X - 0; Z = -1 if != else 0");
return Z;
#else
X |= -X;
return SIGNED_negative_mask(X);
#endif
}
# XXX: for amd64, use set instead of cmov
TYPE TYPE_nonzero_01(TYPE X) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Z32; Z32 = 0; Q32 = 1; X32 & (int8) X32; Z32 = Q32 if !=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Z; Z = 0; Q = 1; X & X; Z = Q if !=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Z; Z = 0; Q = 1; X & X; Z = Q if !=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Z; Z = 0; Q = 1; X & X; Z = Q if !=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Z; X & 255; Z = 1 if != else 0");
16: readasm("arm64; int16 X Z; X & 65535; Z = 1 if != else 0");
32: readasm("arm64; int32 X Z; X - 0; Z = 1 if != else 0");
64: readasm("arm64; int64 X Z; X - 0; Z = 1 if != else 0");
return Z;
#else
X |= -X;
return UNSIGNED_topbit_01(X);
#endif
}
SIGNED:
TYPE TYPE_positive_mask(TYPE X) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Z32; Z32 = 0; Q32 = -1; X32 & (int8) X32; Z32 = Q32 if signed>");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Z; Z = 0; Q = -1; X & X; Z = Q if signed>");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Z; Z = 0; Q = -1; X & X; Z = Q if signed>");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Z; Z = 0; Q = -1; X & X; Z = Q if signed>");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Z; Z = (int8) X; Z - 0; Z = -1 if signed> else 0");
16: readasm("arm64; int16 X Z; Z = (int16) X; Z - 0; Z = -1 if signed> else 0");
32: readasm("arm64; int32 X Z; X - 0; Z = -1 if signed> else 0");
64: readasm("arm64; int64 X Z; X - 0; Z = -1 if signed> else 0");
return Z;
#else
TYPE Z = -X;
Z ^= X & Z;
return TYPE_negative_mask(Z);
#endif
}
SIGNED:
TYPE TYPE_positive_01(TYPE X) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Z32; Z32 = 0; Q32 = 1; X32 & (int8) X32; Z32 = Q32 if signed>");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Z; Z = 0; Q = 1; X & X; Z = Q if signed>");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Z; Z = 0; Q = 1; X & X; Z = Q if signed>");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Z; Z = 0; Q = 1; X & X; Z = Q if signed>");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Z; Z = (int8) X; Z - 0; Z = 1 if signed> else 0");
16: readasm("arm64; int16 X Z; Z = (int16) X; Z - 0; Z = 1 if signed> else 0");
32: readasm("arm64; int32 X Z; X - 0; Z = 1 if signed> else 0");
64: readasm("arm64; int64 X Z; X - 0; Z = 1 if signed> else 0");
return Z;
#else
TYPE Z = -X;
Z ^= X & Z;
return UNSIGNED_topbit_01(Z);
#endif
}
TYPE TYPE_zero_mask(TYPE X) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Z32; Z32 = 0; Q32 = -1; X32 & (int8) X32; Z32 = Q32 if =");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Z; Z = 0; Q = -1; X & X; Z = Q if =");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Z; Z = 0; Q = -1; X & X; Z = Q if =");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Z; Z = 0; Q = -1; X & X; Z = Q if =");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Z; X & 255; Z = -1 if = else 0");
16: readasm("arm64; int16 X Z; X & 65535; Z = -1 if = else 0");
32: readasm("arm64; int32 X Z; X - 0; Z = -1 if = else 0");
64: readasm("arm64; int64 X Z; X - 0; Z = -1 if = else 0");
return Z;
#else
return ~TYPE_nonzero_mask(X);
#endif
}
TYPE TYPE_zero_01(TYPE X) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Z32; Z32 = 0; Q32 = 1; X32 & (int8) X32; Z32 = Q32 if =");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Z; Z = 0; Q = 1; X & X; Z = Q if =");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Z; Z = 0; Q = 1; X & X; Z = Q if =");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Z; Z = 0; Q = 1; X & X; Z = Q if =");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Z; X & 255; Z = 1 if = else 0");
16: readasm("arm64; int16 X Z; X & 65535; Z = 1 if = else 0");
32: readasm("arm64; int32 X Z; X - 0; Z = 1 if = else 0");
64: readasm("arm64; int64 X Z; X - 0; Z = 1 if = else 0");
return Z;
#else
return 1-TYPE_nonzero_01(X);
#endif
}
TYPE TYPE_unequal_mask(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = -1; X32 - (int8) Y32; Z32 = Q32 if !=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if !=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if !=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if !=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = -1 if != else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = -1 if != else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = -1 if != else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = -1 if != else 0");
return Z;
#else
return TYPE_nonzero_mask(X ^ Y);
#endif
}
TYPE TYPE_unequal_01(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = 1; X32 - (int8) Y32; Z32 = Q32 if !=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if !=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if !=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if !=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = 1 if != else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = 1 if != else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = 1 if != else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = 1 if != else 0");
return Z;
#else
return TYPE_nonzero_01(X ^ Y);
#endif
}
TYPE TYPE_equal_mask(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = -1; X32 - (int8) Y32; Z32 = Q32 if =");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if =");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if =");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if =");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = -1 if = else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = -1 if = else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = -1 if = else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = -1 if = else 0");
return Z;
#else
return ~TYPE_unequal_mask(X,Y);
#endif
}
TYPE TYPE_equal_01(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = 1; X32 - (int8) Y32; Z32 = Q32 if =");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if =");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if =");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if =");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = 1 if = else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = 1 if = else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = 1 if = else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = 1 if = else 0");
return Z;
#else
return 1-TYPE_unequal_01(X,Y);
#endif
}
SIGNED:
TYPE TYPE_min(TYPE X,TYPE Y) {
#if amd64
8: int32_t X32 = X,Y32 = Y;
8: readasm("amd64; int32 X32 Y32; X32 - (int8) Y32; X32 = Y32 if signed>");
8: X = X32;
16: readasm("amd64; int16 X Y; X - Y; X = Y if signed>");
32: readasm("amd64; int32 X Y; X - Y; X = Y if signed>");
64: readasm("amd64; int64 X Y; X - Y; X = Y if signed>");
return X;
#elif arm64
8: readasm("arm64; int8 X Y; X = (int8) X; X - (int8) Y; X = X if signed< else Y");
16: readasm("arm64; int16 X Y; X = (int16) X; X - (int16) Y; X = X if signed< else Y");
32: readasm("arm64; int32 X Y; X - Y; X = X if signed< else Y");
64: readasm("arm64; int64 X Y; X - Y; X = X if signed< else Y");
return X;
#else
TYPE R = Y ^ X;
TYPE Z = Y - X;
Z ^= R & (Z ^ Y);
Z = TYPE_negative_mask(Z);
Z &= R;
return X ^ Z;
#endif
}
UNSIGNED:
TYPE TYPE_min(TYPE X,TYPE Y) {
#if amd64
8: uint32_t X32 = X,Y32 = Y;
8: readasm("amd64; int32 X32 Y32; X32 - (int8) Y32; X32 = Y32 if unsigned>");
8: X = X32;
16: readasm("amd64; int16 X Y; X - Y; X = Y if unsigned>");
32: readasm("amd64; int32 X Y; X - Y; X = Y if unsigned>");
64: readasm("amd64; int64 X Y; X - Y; X = Y if unsigned>");
return X;
#elif arm64
8: readasm("arm64; int8 X Y; X = (uint8) X; X - (uint8) Y; X = X if unsigned< else Y");
16: readasm("arm64; int16 X Y; X = (uint16) X; X - (uint16) Y; X = X if unsigned< else Y");
32: readasm("arm64; int32 X Y; X - Y; X = X if unsigned< else Y");
64: readasm("arm64; int64 X Y; X - Y; X = X if unsigned< else Y");
return X;
#else
TYPE R = Y ^ X;
TYPE Z = Y - X;
Z ^= R & (Z ^ Y ^ (((TYPE) 1) << (N-1)));
Z = SIGNED_negative_mask(Z);
Z &= R;
return X ^ Z;
#endif
}
SIGNED:
TYPE TYPE_max(TYPE X,TYPE Y) {
#if amd64
8: int32_t X32 = X,Y32 = Y;
8: readasm("amd64; int32 X32 Y32; X32 - (int8) Y32; X32 = Y32 if signed<");
8: X = X32;
16: readasm("amd64; int16 X Y; X - Y; X = Y if signed<");
32: readasm("amd64; int32 X Y; X - Y; X = Y if signed<");
64: readasm("amd64; int64 X Y; X - Y; X = Y if signed<");
return X;
#elif arm64
8: readasm("arm64; int8 X Y; X = (int8) X; X - (int8) Y; X = Y if signed< else X");
16: readasm("arm64; int16 X Y; X = (int16) X; X - (int16) Y; X = Y if signed< else X");
32: readasm("arm64; int32 X Y; X - Y; X = Y if signed< else X");
64: readasm("arm64; int64 X Y; X - Y; X = Y if signed< else X");
return X;
#else
TYPE R = Y ^ X;
TYPE Z = Y - X;
Z ^= R & (Z ^ Y);
Z = TYPE_negative_mask(Z);
Z &= R;
return Y ^ Z;
#endif
}
UNSIGNED:
TYPE TYPE_max(TYPE X,TYPE Y) {
#if amd64
8: uint32_t X32 = X,Y32 = Y;
8: readasm("amd64; int32 X32 Y32; X32 - (int8) Y32; X32 = Y32 if unsigned<");
8: X = X32;
16: readasm("amd64; int16 X Y; X - Y; X = Y if unsigned<");
32: readasm("amd64; int32 X Y; X - Y; X = Y if unsigned<");
64: readasm("amd64; int64 X Y; X - Y; X = Y if unsigned<");
return X;
#elif arm64
8: readasm("arm64; int8 X Y; X = (uint8) X; X - (uint8) Y; X = Y if unsigned< else X");
16: readasm("arm64; int16 X Y; X = (uint16) X; X - (uint16) Y; X = Y if unsigned< else X");
32: readasm("arm64; int32 X Y; X - Y; X = Y if unsigned< else X");
64: readasm("arm64; int64 X Y; X - Y; X = Y if unsigned< else X");
return X;
#else
TYPE R = Y ^ X;
TYPE Z = Y - X;
Z ^= R & (Z ^ Y ^ (((TYPE) 1) << (N-1)));
Z = SIGNED_negative_mask(Z);
Z &= R;
return Y ^ Z;
#endif
}
SIGNED:
void TYPE_minmax(TYPE *P,TYPE *Q) {
TYPE X = *P;
TYPE Y = *Q;
#if amd64
8: int32_t X32 = X,Y32 = Y,Z32;
8: readasm("amd64; int32 X32 Y32 Z32; X32 - (int8) Y32; Z32 = X32; X32 = Y32 if signed>; Y32 = Z32 if signed>");
8: X = X32; Y = Y32;
16: TYPE Z;
16: readasm("amd64; int16 X Y Z; X - Y; Z = X; X = Y if signed>; Y = Z if signed>");
32: TYPE Z;
32: readasm("amd64; int32 X Y Z; X - Y; Z = X; X = Y if signed>; Y = Z if signed>");
64: TYPE Z;
64: readasm("amd64; int64 X Y Z; X - Y; Z = X; X = Y if signed>; Y = Z if signed>");
*P = X;
*Q = Y;
#elif arm64
TYPE R, S;
8: readasm("arm64; int8 X Y R S; X = (int8) X; X - (int8) Y; R = X if signed< else Y; S = Y if signed< else X");
16: readasm("arm64; int16 X Y R S; X = (int16) X; X - (int16) Y; R = X if signed< else Y; S = Y if signed< else X");
32: readasm("arm64; int32 X Y R S; X - Y; R = X if signed< else Y; S = Y if signed< else X");
64: readasm("arm64; int64 X Y R S; X - Y; R = X if signed< else Y; S = Y if signed< else X");
*P = R;
*Q = S;
#else
TYPE R = Y ^ X;
TYPE Z = Y - X;
Z ^= R & (Z ^ Y);
Z = TYPE_negative_mask(Z);
Z &= R;
X ^= Z;
Y ^= Z;
*P = X;
*Q = Y;
#endif
}
UNSIGNED:
void TYPE_minmax(TYPE *P,TYPE *Q) {
TYPE X = *P;
TYPE Y = *Q;
#if amd64
8: uint32_t X32 = X,Y32 = Y,Z32;
8: readasm("amd64; int32 X32 Y32 Z32; X32 - (int8) Y32; Z32 = X32; X32 = Y32 if unsigned>; Y32 = Z32 if unsigned>");
8: X = X32; Y = Y32;
16: TYPE Z;
16: readasm("amd64; int16 X Y Z; X - Y; Z = X; X = Y if unsigned>; Y = Z if unsigned>");
32: TYPE Z;
32: readasm("amd64; int32 X Y Z; X - Y; Z = X; X = Y if unsigned>; Y = Z if unsigned>");
64: TYPE Z;
64: readasm("amd64; int64 X Y Z; X - Y; Z = X; X = Y if unsigned>; Y = Z if unsigned>");
*P = X;
*Q = Y;
#elif arm64
TYPE R, S;
8: readasm("arm64; int8 X Y R S; X = (uint8) X; X - (uint8) Y; R = X if unsigned< else Y; S = Y if unsigned< else X");
16: readasm("arm64; int16 X Y R S; X = (uint16) X; X - (uint16) Y; R = X if unsigned< else Y; S = Y if unsigned< else X");
32: readasm("arm64; int32 X Y R S; X - Y; R = X if unsigned< else Y; S = Y if unsigned< else X");
64: readasm("arm64; int64 X Y R S; X - Y; R = X if unsigned< else Y; S = Y if unsigned< else X");
*P = R;
*Q = S;
#else
TYPE R = Y ^ X;
TYPE Z = Y - X;
Z ^= R & (Z ^ Y ^ (((TYPE) 1) << (N-1)));
Z = SIGNED_negative_mask(Z);
Z &= R;
X ^= Z;
Y ^= Z;
*P = X;
*Q = Y;
#endif
}
SIGNED:
TYPE TYPE_smaller_mask(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = -1; X32 - (int8) Y32; Z32 = Q32 if signed<");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if signed<");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if signed<");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if signed<");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (int8) X; Z - (int8) Y; Z = -1 if signed< else 0");
16: readasm("arm64; int16 X Y Z; Z = (int16) X; Z - (int16) Y; Z = -1 if signed< else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = -1 if signed< else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = -1 if signed< else 0");
return Z;
#else
TYPE R = X ^ Y;
TYPE Z = X - Y;
Z ^= R & (Z ^ X);
return TYPE_negative_mask(Z);
#endif
}
SIGNED:
TYPE TYPE_smaller_01(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = 1; X32 - (int8) Y32; Z32 = Q32 if signed<");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if signed<");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if signed<");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if signed<");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (int8) X; Z - (int8) Y; Z = 1 if signed< else 0");
16: readasm("arm64; int16 X Y Z; Z = (int16) X; Z - (int16) Y; Z = 1 if signed< else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = 1 if signed< else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = 1 if signed< else 0");
return Z;
#else
TYPE R = X ^ Y;
TYPE Z = X - Y;
Z ^= R & (Z ^ X);
return UNSIGNED_topbit_01(Z);
#endif
}
UNSIGNED:
TYPE TYPE_smaller_mask(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = -1; X32 - (int8) Y32; Z32 = Q32 if unsigned<");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if unsigned<");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if unsigned<");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if unsigned<");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = -1 if unsigned< else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = -1 if unsigned< else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = -1 if unsigned< else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = -1 if unsigned< else 0");
return Z;
#else
TYPE R = X ^ Y;
TYPE Z = X - Y;
Z ^= R & (Z ^ X ^ (((TYPE) 1) << (N-1)));
return SIGNED_negative_mask(Z);
#endif
}
UNSIGNED:
TYPE TYPE_smaller_01(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = 1; X32 - (int8) Y32; Z32 = Q32 if unsigned<");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if unsigned<");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if unsigned<");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if unsigned<");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = 1 if unsigned< else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = 1 if unsigned< else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = 1 if unsigned< else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = 1 if unsigned< else 0");
return Z;
#else
TYPE R = X ^ Y;
TYPE Z = X - Y;
Z ^= R & (Z ^ X ^ (((TYPE) 1) << (N-1)));
return UNSIGNED_topbit_01(Z);
#endif
}
SIGNED:
TYPE TYPE_leq_mask(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = -1; X32 - (int8) Y32; Z32 = Q32 if signed<=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if signed<=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if signed<=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if signed<=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (int8) X; Z - (int8) Y; Z = -1 if signed<= else 0");
16: readasm("arm64; int16 X Y Z; Z = (int16) X; Z - (int16) Y; Z = -1 if signed<= else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = -1 if signed<= else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = -1 if signed<= else 0");
return Z;
#else
return ~TYPE_smaller_mask(Y,X);
#endif
}
SIGNED:
TYPE TYPE_leq_01(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = 1; X32 - (int8) Y32; Z32 = Q32 if signed<=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if signed<=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if signed<=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if signed<=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (int8) X; Z - (int8) Y; Z = 1 if signed<= else 0");
16: readasm("arm64; int16 X Y Z; Z = (int16) X; Z - (int16) Y; Z = 1 if signed<= else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = 1 if signed<= else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = 1 if signed<= else 0");
return Z;
#else
return 1-TYPE_smaller_01(Y,X);
#endif
}
UNSIGNED:
TYPE TYPE_leq_mask(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = -1; X32 - (int8) Y32; Z32 = Q32 if unsigned<=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if unsigned<=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if unsigned<=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = -1; X - Y; Z = Q if unsigned<=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = -1 if unsigned<= else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = -1 if unsigned<= else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = -1 if unsigned<= else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = -1 if unsigned<= else 0");
return Z;
#else
return ~TYPE_smaller_mask(Y,X);
#endif
}
UNSIGNED:
TYPE TYPE_leq_01(TYPE X,TYPE Y) {
#if amd64
8: TYPE Z;
8: int32_t X32 = X,Y32 = Y,Q32,Z32;
8: readasm("amd64; int32 X32 Q32 Y32 Z32; Z32 = 0; Q32 = 1; X32 - (int8) Y32; Z32 = Q32 if unsigned<=");
8: Z = Z32;
16: TYPE Q,Z;
16: readasm("amd64; int16 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if unsigned<=");
32: TYPE Q,Z;
32: readasm("amd64; int32 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if unsigned<=");
64: TYPE Q,Z;
64: readasm("amd64; int64 X Q Y Z; Z = 0; Q = 1; X - Y; Z = Q if unsigned<=");
return Z;
#elif arm64
TYPE Z;
8: readasm("arm64; int8 X Y Z; Z = (uint8) X; Z - (uint8) Y; Z = 1 if unsigned<= else 0");
16: readasm("arm64; int16 X Y Z; Z = (uint16) X; Z - (uint16) Y; Z = 1 if unsigned<= else 0");
32: readasm("arm64; int32 X Y Z; X - Y; Z = 1 if unsigned<= else 0");
64: readasm("arm64; int64 X Y Z; X - Y; Z = 1 if unsigned<= else 0");
return Z;
#else
return 1-TYPE_smaller_01(Y,X);
#endif
}
# XXX: consider *0x...10101 for the denouement _if_ mul is constant-time
# XXX: use popcnt if __SSE4_2__
# XXX: use cnt if arm64 cssc
# XXX: maybe use neon cnt if arm64
int TYPE_ones_num(TYPE X) {
UNSIGNED Y = X;
8: const TYPE C0 = 0x55;
16: const TYPE C0 = 0x5555;
32: const TYPE C0 = 0x55555555;
64: const TYPE C0 = 0x5555555555555555;
8: const TYPE C1 = 0x33;
16: const TYPE C1 = 0x3333;
32: const TYPE C1 = 0x33333333;
64: const TYPE C1 = 0x3333333333333333;
8: const TYPE C2 = 0x0f;
16: const TYPE C2 = 0x0f0f;
32: const TYPE C2 = 0x0f0f0f0f;
64: const TYPE C2 = 0x0f0f0f0f0f0f0f0f;
Y -= ((Y >> 1) & C0);
Y = (Y & C1) + ((Y >> 2) & C1);
Y = (Y + (Y >> 4)) & C2;
16: Y = (Y + (Y >> 8)) & 0xff;
32: Y += Y >> 8;
32: Y = (Y + (Y >> 16)) & 0xff;
64: Y += Y >> 8;
64: Y += Y >> 16;
64: Y = (Y + (Y >> 32)) & 0xff;
return Y;
}
# XXX: use tzcnt if amd64 bmi1
# XXX: use ctz if arm64 cssc
int TYPE_bottomzeros_num(TYPE X) {
#if amd64
8: int32_t fallback = N;
8: int32_t X32 = X;
8: readasm("amd64; int32 X32 fallback; X32 = numbottomzeros_tricky X32; X32 = fallback if =");
8: X = X32;
16: TYPE fallback = N;
16: readasm("amd64; int16 X fallback; X = numbottomzeros_tricky X; X = fallback if =");
32: TYPE fallback = N;
32: readasm("amd64; int32 X fallback; X = numbottomzeros_tricky X; X = fallback if =");
64: TYPE fallback = N;
64: readasm("amd64; int64 X fallback; X = numbottomzeros_tricky X; X = fallback if =");
return X;
#elif arm64
int64_t Y;
8: readasm("arm64; int8 X Y; Y = X | -256; Y = bitrev32 Y; Y = numbottomzeros Y");
16: readasm("arm64; int16 X Y; Y = X | -65536; Y = bitrev32 Y; Y = numbottomzeros Y");
32: readasm("arm64; int32 X Y; Y = bitrev32 X; Y = numbottomzeros Y");
64: readasm("arm64; int64 X Y; Y = bitrev64 X; Y = numbottomzeros Y");
return Y;
#else
TYPE Y = X ^ (X-1);
Y = ((SIGNED) Y) >> 1;
Y &= ~(X & (((TYPE) 1) << (N-1)));
return TYPE_ones_num(Y);
#endif
}
tinyssh-20250126/cryptoint/int16_optblocker.c 0000664 0000000 0000000 00000000225 14745512304 0021046 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_int16.h"
volatile crypto_int16 crypto_int16_optblocker = 0;
tinyssh-20250126/cryptoint/int32_optblocker.c 0000664 0000000 0000000 00000000225 14745512304 0021044 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_int32.h"
volatile crypto_int32 crypto_int32_optblocker = 0;
tinyssh-20250126/cryptoint/int64_optblocker.c 0000664 0000000 0000000 00000000225 14745512304 0021051 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_int64.h"
volatile crypto_int64 crypto_int64_optblocker = 0;
tinyssh-20250126/cryptoint/int8_optblocker.c 0000664 0000000 0000000 00000000222 14745512304 0020764 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_int8.h"
volatile crypto_int8 crypto_int8_optblocker = 0;
tinyssh-20250126/cryptoint/intN_optblocker.c 0000664 0000000 0000000 00000000222 14745512304 0021012 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_intN.h"
volatile crypto_intN crypto_intN_optblocker = 0;
tinyssh-20250126/cryptoint/namespace 0000664 0000000 0000000 00000000010 14745512304 0017364 0 ustar 00root root 0000000 0000000 tinyssh
tinyssh-20250126/cryptoint/readasm.py 0000775 0000000 0000000 00000044663 14745512304 0017524 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
import re
import sys
machinedesc = {}
# note for qhasm users:
# the machine descriptions here have, e.g.,
# int8 meaning where the C ABI stores an int8,
# such as a 64-bit integer register on amd64
# ===== amd64
machinedesc['amd64'] = r'''
int8 r:var/r=int8:
int16 r:var/r=int16:
int32 r:var/r=int32:
int64 r:var/r=int64:
int8 r s:var/r=int8:var/s=int8:
int16 r s:var/r=int16:var/s=int16:
int32 r s:var/r=int32:var/s=int32:
int64 r s:var/r=int64:var/s=int64:
int8 r s t:var/r=int8:var/s=int8:var/t=int8:
int16 r s t:var/r=int16:var/s=int16:var/t=int16:
int32 r s t:var/r=int32:var/s=int32:var/t=int32:
int64 r s t:var/r=int64:var/s=int64:var/t=int64:
int8 r s t u:var/r=int8:var/s=int8:var/t=int8:var/u=int8:
int16 r s t u:var/r=int16:var/s=int16:var/t=int16:var/u=int16:
int32 r s t u:var/r=int32:var/s=int32:var/t=int32:var/u=int32:
int64 r s t u:var/r=int64:var/s=int64:var/t=int64:var/u=int64:
r = 0:>r=int8:asm/xorb >r,>r:>?cc:
r = 0:>r=int16:asm/xorw >r,>r:>?cc:
r = 0:>r=int32:asm/xorl >r,>r:>?cc:
r = 0:>r=int64:asm/xorq >r,>r:>?cc:
r = n:>r=int8:#n:asm/movb $#n,>r:
r = n:>r=int16:#n:asm/movw $#n,>r:
r = n:>r=int32:#n:asm/movl $#n,>r:
r = n:>r=int64:#n:asm/movq $#n,>r:
r = -n:>r=int8:#n:asm/movb $-#n,>r:
r = -n:>r=int16:#n:asm/movw $-#n,>r:
r = -n:>r=int32:#n:asm/movl $-#n,>r:
r = -n:>r=int64:#n:asm/movq $-#n,>r:
r signed>>= n:+r=int8:#n:asm/sarb $#n,+r:>?cc:
r signed>>= n:+r=int16:#n:asm/sarw $#n,+r:>?cc:
r signed>>= n:+r=int32:#n:asm/sarl $#n,+r:>?cc:
r signed>>= n:+r=int64:#n:asm/sarq $#n,+r:>?cc:
r signed>>= s:+r=int8:?cc:
r signed>>= s:+r=int16:?cc:
r signed>>= s:+r=int32:?cc:
r signed>>= s:+r=int64:?cc:
r unsigned>>= n:+r=int8:#n:asm/shrb $#n,+r:>?cc:
r unsigned>>= n:+r=int16:#n:asm/shrw $#n,+r:>?cc:
r unsigned>>= n:+r=int32:#n:asm/shrl $#n,+r:>?cc:
r unsigned>>= n:+r=int64:#n:asm/shrq $#n,+r:>?cc:
r unsigned>>= s:+r=int8:?cc:
r unsigned>>= s:+r=int16:?cc:
r unsigned>>= s:+r=int32:?cc:
r unsigned>>= s:+r=int64:?cc:
r <<= n:+r=int8:#n:asm/shlb $#n,+r:>?cc:
r <<= n:+r=int16:#n:asm/shlw $#n,+r:>?cc:
r <<= n:+r=int32:#n:asm/shll $#n,+r:>?cc:
r <<= n:+r=int64:#n:asm/shlq $#n,+r:>?cc:
r <<= s:+r=int8:?cc:
r <<= s:+r=int16:?cc:
r <<= s:+r=int32:?cc:
r <<= s:+r=int64:?cc:
r &= n:+r=int8:#n:asm/andb $#n,+r:>?cc:
r &= n:+r=int16:#n:asm/andw $#n,+r:>?cc:
r &= n:+r=int32:#n:asm/andl $#n,+r:>?cc:
r &= n:+r=int64:#n:asm/andq $#n,+r:>?cc:
r & (int8) s:?cc:
r & s:?cc:
r & s:?cc:
r & s:?cc:
r - (int8) s:?cc:
r - s:?cc:
r - s:?cc:
r - s:?cc:
r = s:>r=int16:r:
r = s:>r=int32:r:
r = s:>r=int64:r:
r = s if signed<:+r=int16::+r=int16::+r=int32::+r=int64::+r=int16::+r=int32::+r=int64:r=int16:?cc:asm/bsfw r:
r = numbottomzeros_tricky s:>r=int32:?cc:asm/bsfl r:
r = numbottomzeros_tricky s:>r=int64:?cc:asm/bsfq r:
'''
# ===== arm64
machinedesc['arm64'] = r'''
int8 r:var/r=int8:
int16 r:var/r=int16:
int32 r:var/r=int32:
int64 r:var/r=int64:
int8 r s:var/r=int8:var/s=int8:
int16 r s:var/r=int16:var/s=int16:
int32 r s:var/r=int32:var/s=int32:
int64 r s:var/r=int64:var/s=int64:
int8 r s t:var/r=int8:var/s=int8:var/t=int8:
int16 r s t:var/r=int16:var/s=int16:var/t=int16:
int32 r s t:var/r=int32:var/s=int32:var/t=int32:
int64 r s t:var/r=int64:var/s=int64:var/t=int64:
int8 r s t u:var/r=int8:var/s=int8:var/t=int8:var/u=int8:
int16 r s t u:var/r=int16:var/s=int16:var/t=int16:var/u=int16:
int32 r s t u:var/r=int32:var/s=int32:var/t=int32:var/u=int32:
int64 r s t u:var/r=int64:var/s=int64:var/t=int64:var/u=int64:
r = s signed>> n:>r=int32:r,> n:>r=int64:r,> n:>r=int32:r,> n:>r=int64:r,> t:>r=int8:r,> t:>r=int16:r,> t:>r=int32:r,> t:>r=int64:r,> t:>r=int8:r,> t:>r=int16:r,> t:>r=int32:r,> t:>r=int64:r,r=int8:r,r=int16:r,r=int32:r,r=int64:r,r=int8:r,r=int16:r,r=int8:r,r=int16:r,r=int8:r,r=int8:r,r=int16:r,r=int16:r,r=int8:r,r=int16:r,?cc:
r & n:?cc:
r - n:?cc:
r - n:?cc:
r - n:?cc:
r - n:?cc:
r - s:?cc:
r - s:?cc:
r - s:?cc:
r - s:?cc:
r - (int8) s:?cc:
r - (uint8) s:?cc:
r - (int16) s:?cc:
r - (uint16) s:?cc:
r = -1 if != else 0:>r=int8:r,ne:
r = -1 if != else 0:>r=int16:r,ne:
r = -1 if != else 0:>r=int32:r,ne:
r = -1 if != else 0:>r=int64:r,ne:
r = -1 if = else 0:>r=int8:r,eq:
r = -1 if = else 0:>r=int16:r,eq:
r = -1 if = else 0:>r=int32:r,eq:
r = -1 if = else 0:>r=int64:r,eq:
r = -1 if signed< else 0:>r=int8:r,lt:
r = -1 if signed< else 0:>r=int16:r,lt:
r = -1 if signed< else 0:>r=int32:r,lt:
r = -1 if signed< else 0:>r=int64:r,lt:
r = -1 if signed> else 0:>r=int8:r,gt:
r = -1 if signed> else 0:>r=int16:r,gt:
r = -1 if signed> else 0:>r=int32:r,gt:
r = -1 if signed> else 0:>r=int64:r,gt:
r = -1 if signed<= else 0:>r=int8:r,le:
r = -1 if signed<= else 0:>r=int16:r,le:
r = -1 if signed<= else 0:>r=int32:r,le:
r = -1 if signed<= else 0:>r=int64:r,le:
r = -1 if unsigned< else 0:>r=int8:r,lo:
r = -1 if unsigned< else 0:>r=int16:r,lo:
r = -1 if unsigned< else 0:>r=int32:r,lo:
r = -1 if unsigned< else 0:>r=int64:r,lo:
r = -1 if unsigned<= else 0:>r=int8:r,ls:
r = -1 if unsigned<= else 0:>r=int16:r,ls:
r = -1 if unsigned<= else 0:>r=int32:r,ls:
r = -1 if unsigned<= else 0:>r=int64:r,ls:
r = 1 if != else 0:>r=int8:r,ne:
r = 1 if != else 0:>r=int16:r,ne:
r = 1 if != else 0:>r=int32:r,ne:
r = 1 if != else 0:>r=int64:r,ne:
r = 1 if = else 0:>r=int8:r,eq:
r = 1 if = else 0:>r=int16:r,eq:
r = 1 if = else 0:>r=int32:r,eq:
r = 1 if = else 0:>r=int64:r,eq:
r = 1 if signed< else 0:>r=int8:r,lt:
r = 1 if signed< else 0:>r=int16:r,lt:
r = 1 if signed< else 0:>r=int32:r,lt:
r = 1 if signed< else 0:>r=int64:r,lt:
r = 1 if signed> else 0:>r=int8:r,gt:
r = 1 if signed> else 0:>r=int16:r,gt:
r = 1 if signed> else 0:>r=int32:r,gt:
r = 1 if signed> else 0:>r=int64:r,gt:
r = 1 if signed<= else 0:>r=int8:r,le:
r = 1 if signed<= else 0:>r=int16:r,le:
r = 1 if signed<= else 0:>r=int32:r,le:
r = 1 if signed<= else 0:>r=int64:r,le:
r = 1 if unsigned< else 0:>r=int8:r,lo:
r = 1 if unsigned< else 0:>r=int16:r,lo:
r = 1 if unsigned< else 0:>r=int32:r,lo:
r = 1 if unsigned< else 0:>r=int64:r,lo:
r = 1 if unsigned<= else 0:>r=int8:r,ls:
r = 1 if unsigned<= else 0:>r=int16:r,ls:
r = 1 if unsigned<= else 0:>r=int32:r,ls:
r = 1 if unsigned<= else 0:>r=int64:r,ls:
r = s if signed< else t:>r=int8:r,r=int16:r,r=int32:r,r=int64:r,r=int8:r,r=int16:r,r=int32:r,r=int64:r,r=int8:r,r=int16:r,r=int32:r,r=int64:r,r=int8:r,r=int16:r,r=int32:r,r=int64:r,> n)):>r=int8:r,> n)):>r=int16:r,> n)):>r=int32:r,> n)):>r=int64:r,> n):>r=int8:r,> n):>r=int16:r,> n):>r=int32:r,> n):>r=int64:r,'):
if x[1:] == '?cc':
if x[0] != '<': insnwrite += ['?cc']
if x[0] != '>': insnread += ['?cc']
continue
if x[0] != '<': insnwrite += [x[1]]
if x[0] != '>': insnread += [x[1]]
insnvars += [x[1]]
assert x[2] == '='
insnvartype[x[1]] = x[3:].split('#')[0]
if len(x[3:].split('#')) > 1:
insnvarpos[x[1]] = int(x[3:].split('#')[1])
continue
if x.startswith('var/'):
insnvars += [x[4]]
assert x[5] == '='
insnvartype[x[4]] = x[6:]
insnmakevars += [x[4]]
continue
if x.startswith('asm/'):
insnasm += [x[4:]]
continue
raise Exception(x)
insn = tokens(insndesc[0])
insnpos = 0
linepos = 0
while True:
if insnpos == len(insn) and linepos == len(line):
foundinsn = True
if insnpos == len(insn) or linepos == len(line):
break
x = insn[insnpos]
y = line[linepos]
if x in insnvars:
if y in vartype:
if vartype[y] != insnvartype[x]:
break # line and insn both have variables, but different types
if x in insnvar2line:
if insnvar2line[x] != y:
break # insn variable already assigned to something different in line
else:
insnvar2line[x] = y
else:
if not isvarname(y):
break # not an acceptable variable name
insnvar2line[x] = y
else:
if y in vartype:
break # XXX: but maybe sometimes want to allow variable in line to match literal in insn
if y != x:
break # non-matching literals
insnpos += 1
linepos += 1
if foundinsn: break
if not foundinsn: print(line)
assert foundinsn
insnvar2line['?cc'] = '?cc'
for v in insnmakevars:
w = insnvar2line[v]
vartype[w] = insnvartype[v]
for v in insnvar2line:
if v == '?cc': continue
if insnvartype[v] == '#': continue
w = insnvar2line[v]
if w not in vartype:
raise Exception(f'undefined variable {w}')
for v in insnread:
w = insnvar2line[v]
if v in insnvarpos:
assert insnvarpos[v] == 4
assert machine == 'amd64'
rcxvars.add(w)
if w not in outputvars:
if w not in inputvars:
inputvars += [w]
for z in outputvars:
earlyclobber.add(z)
for v in insnwrite:
w = insnvar2line[v]
if w not in outputvars:
outputvars += [w]
for asm in insnasm:
todo += [(asm,insnvar2line)]
need8 = set()
todo2 = []
for asm,insnvar2line in todo:
todo2 += [('asm',)]
while len(asm) > 0:
if asm[0] in ('<','+','>'):
if asm[2:].startswith('%8'):
todo2 += [('var8',insnvar2line[asm[1]])]
need8.add(insnvar2line[asm[1]])
asm = asm[4:]
else:
todo2 += [('var',insnvar2line[asm[1]])]
asm = asm[2:]
elif asm[0] == '#':
todo2 += [('str',insnvar2line[asm[1]])]
asm = asm[2:]
else:
todo2 += [('str',asm[0])]
asm = asm[1:]
varnextpos = 0
var2name = {}
outputs = []
for w in outputvars:
if w == '?cc': continue
if machine == 'arm64' and vartype[w] != 'int64': # XXX: abstract this
var2name[w] = f'%w{varnextpos}'
else:
var2name[w] = f'%{varnextpos}'
varnextpos += 1
regtype = 'r'
if w in need8: regtype = 'q'
if w in rcxvars: regtype = 'c'
if w in earlyclobber: regtype = '&'+regtype
if w in inputvars:
outputs += [f'"+{regtype}"({w})']
else:
outputs += [f'"={regtype}"({w})']
inputs = []
for w in inputvars:
if w in outputvars: continue
assert w != '?cc'
if machine == 'arm64' and vartype[w] != 'int64': # XXX: abstract this
var2name[w] = f'%w{varnextpos}'
else:
var2name[w] = f'%{varnextpos}'
varnextpos += 1
regtype = 'r'
if w in need8: regtype = 'q'
if w in rcxvars: regtype = 'c'
inputs += [f'"{regtype}"({w})']
clobbers = []
for w in outputvars:
if w != '?cc': continue
clobbers += ['"cc"']
result = ''
for T in todo2:
if T[0] == 'asm':
if result != '': result += '\\n '
elif T[0] == 'var8':
result += var2name[T[1]].replace('%','%b')
elif T[0] == 'var':
result += var2name[T[1]]
else:
assert T[0] == 'str'
result += T[1]
outputs = ', '.join(outputs)
if len(outputs) > 0: outputs += ' '
inputs = ', '.join(inputs)
if len(inputs) > 0: inputs += ' '
clobbers = ', '.join(clobbers)
result = f'__asm__ ("{result}" : {outputs}: {inputs}: {clobbers})'
return result
def substitute(program):
result = ''
for line in program.splitlines():
m = re.fullmatch(r'(.*)\breadasm\("([^"]*)"\)(.*)',line)
if m:
result += m.group(1)+process(m.group(2))+m.group(3)+'\n'
else:
result += line+'\n'
return result
def test():
print(process('amd64; int64 X; X signed>>= 63'))
print(process('arm64; int8 X; int8 Y; X = (int8) X; Y = (int8) Y; X - Y; X = Y if signed< else X'))
print(process('arm64; int8 X; int8 Y; int8 Z; Z = (uint8) X; Z - (uint8) Y; Z = -1 if unsigned<= else 0'))
print(process('arm64; int64 X; int64 Y; int64 R; int64 S; X - Y; R = X if unsigned< else Y; S = Y if unsigned< else X'))
if __name__ == '__main__':
test()
tinyssh-20250126/cryptoint/specialize.py 0000775 0000000 0000000 00000005063 14745512304 0020227 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
import os
import readasm
with open('namespace') as f:
projectnamespace = f.readline().strip()
with open('crypto_intN.h') as f:
intN = f.read()
with open('crypto_uintN.h') as f:
uintN = f.read()
for bits in 8,16,32,64:
for ui in 'int','uint':
TYPE = f'crypto_{ui}{bits}'
with open(f'{TYPE}.h','w') as f:
contents = intN if ui == 'int' else uintN
contents = contents.replace('N',str(bits))
contents = contents.replace('namespace',projectnamespace)
contents = readasm.substitute(contents)
contents = contents.replace('amd64','defined(__GNUC__) && defined(__x86_64__)')
contents = contents.replace('arm64','defined(__GNUC__) && defined(__aarch64__)')
newcontents = ''
for line in contents.splitlines():
if ':' in line:
condbits = line.split(':')[0].strip()
if condbits.isnumeric():
if int(condbits) != bits:
continue
line = ':'.join(line.split(':')[1:])
newcontents += line+'\n'
contents = newcontents
tounroll = f' int {TYPE}_k;\n for ({TYPE}_k = 0;{TYPE}_k < {bits};{TYPE}_k += 8)\n {TYPE}_z |= (({TYPE}) (*{TYPE}_s++)) << {TYPE}_k;'
unrolled = '\n'.join(f' {TYPE}_z |= (({TYPE}) (*{TYPE}_s++)) << {k};' for k in range(0,bits,8))
contents = contents.replace(tounroll,unrolled)
tounroll = f' int {TYPE}_k;\n for ({TYPE}_k = {bits} - 8;{TYPE}_k >= 0;{TYPE}_k -= 8)\n {TYPE}_z |= (({TYPE}) (*{TYPE}_s++)) << {TYPE}_k;'
unrolled = '\n'.join(f' {TYPE}_z |= (({TYPE}) (*{TYPE}_s++)) << {k};' for k in reversed(range(0,bits,8)))
contents = contents.replace(tounroll,unrolled)
tounroll = f' int {TYPE}_k;\n for ({TYPE}_k = 0;{TYPE}_k < {bits};{TYPE}_k += 8)\n *{TYPE}_s++ = {TYPE}_x >> {TYPE}_k;'
unrolled = '\n'.join(f' *{TYPE}_s++ = {TYPE}_x >> {k};' for k in range(0,bits,8))
contents = contents.replace(tounroll,unrolled)
tounroll = f' int {TYPE}_k;\n for ({TYPE}_k = {bits} - 8;{TYPE}_k >= 0;{TYPE}_k -= 8)\n *{TYPE}_s++ = {TYPE}_x >> {TYPE}_k;'
unrolled = '\n'.join(f' *{TYPE}_s++ = {TYPE}_x >> {k};' for k in reversed(range(0,bits,8)))
contents = contents.replace(tounroll,unrolled)
f.write(contents)
for intc in sorted(os.listdir('.')):
if not intc.endswith('.c'): continue
if not (intc.startswith('int') or intc.startswith('uint')): continue
targetintc = intc.replace('N',str(bits))
with open(intc) as f:
contents = f.read()
with open(targetintc,'w') as f:
f.write(contents.replace('N',str(bits)))
tinyssh-20250126/cryptoint/uint16_optblocker.c 0000664 0000000 0000000 00000000246 14745512304 0021236 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_uint16.h"
volatile crypto_uint16_signed crypto_uint16_signed_optblocker = 0;
tinyssh-20250126/cryptoint/uint32_optblocker.c 0000664 0000000 0000000 00000000246 14745512304 0021234 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_uint32.h"
volatile crypto_uint32_signed crypto_uint32_signed_optblocker = 0;
tinyssh-20250126/cryptoint/uint64_optblocker.c 0000664 0000000 0000000 00000000246 14745512304 0021241 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_uint64.h"
volatile crypto_uint64_signed crypto_uint64_signed_optblocker = 0;
tinyssh-20250126/cryptoint/uint8_optblocker.c 0000664 0000000 0000000 00000000243 14745512304 0021154 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_uint8.h"
volatile crypto_uint8_signed crypto_uint8_signed_optblocker = 0;
tinyssh-20250126/cryptoint/uintN_optblocker.c 0000664 0000000 0000000 00000000243 14745512304 0021202 0 ustar 00root root 0000000 0000000 /* auto-generated: cd cryptoint; ./autogen */
/* cryptoint 20241003 */
#include "crypto_uintN.h"
volatile crypto_uintN_signed crypto_uintN_signed_optblocker = 0;
tinyssh-20250126/cryptoint/version 0000664 0000000 0000000 00000000023 14745512304 0017121 0 ustar 00root root 0000000 0000000 cryptoint 20241003
tinyssh-20250126/die.c 0000664 0000000 0000000 00000001032 14745512304 0014364 0 ustar 00root root 0000000 0000000 #include "global.h"
#include "log.h"
#include "die.h"
void die_usage(const char *x) {
log_u1(x);
global_die(100);
}
void die_fatal_(const char *fn, unsigned long long line, const char *trouble,
const char *d, const char *f) {
if (d) {
if (f)
log_9_(1, 0, fn, line, trouble, " ", d, "/", f, 0, 0, 0, 0);
else
log_9_(1, 0, fn, line, trouble, " ", d, 0, 0, 0, 0, 0, 0);
}
else { log_9_(1, 0, fn, line, trouble, 0, 0, 0, 0, 0, 0, 0, 0); }
global_die(111);
}
tinyssh-20250126/die.h 0000664 0000000 0000000 00000000430 14745512304 0014372 0 ustar 00root root 0000000 0000000 #ifndef DIE_H____
#define DIE_H____
extern void die_usage(const char *);
extern void die_fatal_(const char *, unsigned long long, const char *,
const char *, const char *);
#define die_fatal(a, b, cc) die_fatal_(__FILE__, __LINE__, (a), (b), (cc))
#endif
tinyssh-20250126/dropuidgid.c 0000664 0000000 0000000 00000001654 14745512304 0015767 0 ustar 00root root 0000000 0000000 /*
20140420
Jan Mojzis
Public domain.
*/
#include