Crypt-PQClean-Sign
view release on metacpan or search on metacpan
pqclean/.clang-tidy view on Meta::CPAN
User: thom
CheckOptions:
- key: abseil-string-find-startswith.AbseilStringsMatchHeader
value: absl/strings/match.h
- key: abseil-string-find-startswith.IncludeStyle
value: llvm
- key: abseil-string-find-startswith.StringLikeClasses
value: '::std::basic_string'
- key: bugprone-argument-comment.StrictMode
value: '0'
- key: bugprone-assert-side-effect.AssertMacros
value: assert
- key: bugprone-assert-side-effect.CheckFunctionCalls
value: '0'
- key: bugprone-dangling-handle.HandleClasses
value: 'std::basic_string_view;std::experimental::basic_string_view'
- key: bugprone-exception-escape.FunctionsThatShouldNotThrow
value: ''
- key: bugprone-exception-escape.IgnoredExceptions
value: ''
- key: bugprone-misplaced-widening-cast.CheckImplicitCasts
pqclean/.clang-tidy view on Meta::CPAN
- key: hicpp-use-auto.RemoveStars
value: '0'
- key: hicpp-use-emplace.ContainersWithPushBack
value: '::std::vector;::std::list;::std::deque'
- key: hicpp-use-emplace.SmartPointers
value: '::std::shared_ptr;::std::unique_ptr;::std::auto_ptr;::std::weak_ptr'
- key: hicpp-use-emplace.TupleMakeFunctions
value: '::std::make_pair;::std::make_tuple'
- key: hicpp-use-emplace.TupleTypes
value: '::std::pair;::std::tuple'
- key: hicpp-use-equals-default.IgnoreMacros
value: '1'
- key: hicpp-use-noexcept.ReplacementString
value: ''
- key: hicpp-use-noexcept.UseNoexceptFalse
value: '1'
- key: hicpp-use-nullptr.NullMacros
value: ''
- key: llvm-namespace-comment.ShortNamespaceLines
value: '1'
- key: llvm-namespace-comment.SpacesBeforeComments
value: '1'
- key: misc-definitions-in-headers.HeaderFileExtensions
value: ',h,hh,hpp,hxx'
- key: misc-definitions-in-headers.UseHeaderFileExtension
value: '1'
- key: misc-throw-by-value-catch-by-reference.CheckThrowTemporaries
value: '1'
- key: misc-unused-parameters.StrictMode
value: '0'
- key: modernize-loop-convert.MaxCopySize
value: '16'
- key: modernize-loop-convert.MinConfidence
value: reasonable
- key: modernize-loop-convert.NamingStyle
value: CamelCase
- key: modernize-make-shared.IgnoreMacros
value: '1'
- key: modernize-make-shared.MakeSmartPtrFunction
value: 'std::make_shared'
- key: modernize-make-shared.MakeSmartPtrFunctionHeader
value: memory
- key: modernize-make-unique.IgnoreMacros
value: '1'
- key: modernize-make-unique.MakeSmartPtrFunction
value: 'std::make_unique'
- key: modernize-make-unique.MakeSmartPtrFunctionHeader
value: memory
- key: modernize-pass-by-value.IncludeStyle
value: llvm
- key: modernize-pass-by-value.ValuesOnly
value: '0'
- key: modernize-raw-string-literal.ReplaceShorterLiterals
value: '0'
- key: modernize-replace-auto-ptr.IncludeStyle
value: llvm
- key: modernize-replace-random-shuffle.IncludeStyle
value: llvm
- key: modernize-use-auto.MinTypeNameLength
value: '5'
- key: modernize-use-auto.RemoveStars
value: '0'
- key: modernize-use-default-member-init.IgnoreMacros
value: '1'
- key: modernize-use-default-member-init.UseAssignment
value: '0'
- key: modernize-use-emplace.ContainersWithPushBack
value: '::std::vector;::std::list;::std::deque'
- key: modernize-use-emplace.SmartPointers
value: '::std::shared_ptr;::std::unique_ptr;::std::auto_ptr;::std::weak_ptr'
- key: modernize-use-emplace.TupleMakeFunctions
value: '::std::make_pair;::std::make_tuple'
- key: modernize-use-emplace.TupleTypes
value: '::std::pair;::std::tuple'
- key: modernize-use-equals-default.IgnoreMacros
value: '1'
- key: modernize-use-noexcept.ReplacementString
value: ''
- key: modernize-use-noexcept.UseNoexceptFalse
value: '1'
- key: modernize-use-nullptr.NullMacros
value: 'NULL'
- key: modernize-use-transparent-functors.SafeMode
value: '0'
- key: modernize-use-using.IgnoreMacros
value: '1'
- key: objc-forbidden-subclassing.ForbiddenSuperClassNames
value: 'ABNewPersonViewController;ABPeoplePickerNavigationController;ABPersonViewController;ABUnknownPersonViewController;NSHashTable;NSMapTable;NSPointerArray;NSPointerFunctions;NSTimer;UIActionSheet;UIAlertView;UIImagePickerController...
- key: objc-property-declaration.Acronyms
value: ''
- key: objc-property-declaration.IncludeDefaultAcronyms
value: '1'
- key: performance-faster-string-find.StringLikeClasses
value: 'std::basic_string'
- key: performance-for-range-copy.WarnOnAllAutoCopies
pqclean/.clang-tidy view on Meta::CPAN
- key: readability-function-size.StatementThreshold
value: '800'
- key: readability-function-size.VariableThreshold
value: '4294967295'
- key: readability-identifier-naming.IgnoreFailedSplit
value: '0'
- key: readability-implicit-bool-conversion.AllowIntegerConditions
value: '0'
- key: readability-implicit-bool-conversion.AllowPointerConditions
value: '0'
- key: readability-inconsistent-declaration-parameter-name.IgnoreMacros
value: '1'
- key: readability-inconsistent-declaration-parameter-name.Strict
value: '0'
- key: readability-inconsistent-declaration-parameter-name.Strict
value: '0'
- key: readability-simplify-boolean-expr.ChainedConditionalReturn
value: '0'
- key: readability-simplify-subscript-expr.Types
value: '::std::basic_string;::std::basic_string_view;::std::vector;::std::array'
- key: readability-static-accessed-through-instance.NameSpecifierNestingThreshold
pqclean/crypto_sign/falcon-1024/aarch64/macrous.h view on Meta::CPAN
/*
* Macro for sign/unsigned integer
*
* =============================================================================
* Copyright (c) 2023 by Cryptographic Engineering Research Group (CERG)
* ECE Department, George Mason University
* Fairfax, VA, U.S.A.
* Author: Duc Tri Nguyen
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
pqclean/crypto_sign/falcon-1024/aarch64/macrous.h view on Meta::CPAN
#define vmulla_lo(d, c, a, b) d = vmlal_s16(c, vget_low_s16(a), vget_low_s16(b));
#define vmulla_hi(d, c, a, b) d = vmlal_high_s16(c, a, b);
#define vadd(c, a, b) c = vaddq_u32(a, b);
#define vaddv(c, a) c = vaddvq_u32(a);
#define vor(c, a, b) c = vorrq_u32(a, b);
// Macro for NTT operation. Using signed 16-bit.
#define vload_s16_4(c, addr) c = vld4q_s16(addr);
#define vload_s16_x2(c, addr) c = vld1q_s16_x2(addr);
#define vload_s16_x4(c, addr) c = vld1q_s16_x4(addr);
#define vstore_s16_x4(addr, c) vst1q_s16_x4(addr, c);
#define vstore_s16_x2(addr, c) vst1q_s16_x2(addr, c);
#define vstore_s16_4(add, c) vst4q_s16(add, c);
/*
* Strategy for NTT:
pqclean/crypto_sign/falcon-512/aarch64/macrous.h view on Meta::CPAN
/*
* Macro for sign/unsigned integer
*
* =============================================================================
* Copyright (c) 2023 by Cryptographic Engineering Research Group (CERG)
* ECE Department, George Mason University
* Fairfax, VA, U.S.A.
* Author: Duc Tri Nguyen
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
pqclean/crypto_sign/falcon-512/aarch64/macrous.h view on Meta::CPAN
#define vmulla_lo(d, c, a, b) d = vmlal_s16(c, vget_low_s16(a), vget_low_s16(b));
#define vmulla_hi(d, c, a, b) d = vmlal_high_s16(c, a, b);
#define vadd(c, a, b) c = vaddq_u32(a, b);
#define vaddv(c, a) c = vaddvq_u32(a);
#define vor(c, a, b) c = vorrq_u32(a, b);
// Macro for NTT operation. Using signed 16-bit.
#define vload_s16_4(c, addr) c = vld4q_s16(addr);
#define vload_s16_x2(c, addr) c = vld1q_s16_x2(addr);
#define vload_s16_x4(c, addr) c = vld1q_s16_x4(addr);
#define vstore_s16_x4(addr, c) vst1q_s16_x4(addr, c);
#define vstore_s16_x2(addr, c) vst1q_s16_x2(addr, c);
#define vstore_s16_4(add, c) vst4q_s16(add, c);
/*
* Strategy for NTT:
pqclean/crypto_sign/falcon-padded-1024/aarch64/macrous.h view on Meta::CPAN
/*
* Macro for sign/unsigned integer
*
* =============================================================================
* Copyright (c) 2023 by Cryptographic Engineering Research Group (CERG)
* ECE Department, George Mason University
* Fairfax, VA, U.S.A.
* Author: Duc Tri Nguyen
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
pqclean/crypto_sign/falcon-padded-1024/aarch64/macrous.h view on Meta::CPAN
#define vmulla_lo(d, c, a, b) d = vmlal_s16(c, vget_low_s16(a), vget_low_s16(b));
#define vmulla_hi(d, c, a, b) d = vmlal_high_s16(c, a, b);
#define vadd(c, a, b) c = vaddq_u32(a, b);
#define vaddv(c, a) c = vaddvq_u32(a);
#define vor(c, a, b) c = vorrq_u32(a, b);
// Macro for NTT operation. Using signed 16-bit.
#define vload_s16_4(c, addr) c = vld4q_s16(addr);
#define vload_s16_x2(c, addr) c = vld1q_s16_x2(addr);
#define vload_s16_x4(c, addr) c = vld1q_s16_x4(addr);
#define vstore_s16_x4(addr, c) vst1q_s16_x4(addr, c);
#define vstore_s16_x2(addr, c) vst1q_s16_x2(addr, c);
#define vstore_s16_4(add, c) vst4q_s16(add, c);
/*
* Strategy for NTT:
pqclean/crypto_sign/falcon-padded-512/aarch64/macrous.h view on Meta::CPAN
/*
* Macro for sign/unsigned integer
*
* =============================================================================
* Copyright (c) 2023 by Cryptographic Engineering Research Group (CERG)
* ECE Department, George Mason University
* Fairfax, VA, U.S.A.
* Author: Duc Tri Nguyen
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
pqclean/crypto_sign/falcon-padded-512/aarch64/macrous.h view on Meta::CPAN
#define vmulla_lo(d, c, a, b) d = vmlal_s16(c, vget_low_s16(a), vget_low_s16(b));
#define vmulla_hi(d, c, a, b) d = vmlal_high_s16(c, a, b);
#define vadd(c, a, b) c = vaddq_u32(a, b);
#define vaddv(c, a) c = vaddvq_u32(a);
#define vor(c, a, b) c = vorrq_u32(a, b);
// Macro for NTT operation. Using signed 16-bit.
#define vload_s16_4(c, addr) c = vld4q_s16(addr);
#define vload_s16_x2(c, addr) c = vld1q_s16_x2(addr);
#define vload_s16_x4(c, addr) c = vld1q_s16_x4(addr);
#define vstore_s16_x4(addr, c) vst1q_s16_x4(addr, c);
#define vstore_s16_x2(addr, c) vst1q_s16_x2(addr, c);
#define vstore_s16_4(add, c) vst4q_s16(add, c);
/*
* Strategy for NTT:
pqclean/crypto_sign/sphincs-sha2-128f-simple/avx2/wotsx8.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x8 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8 * 8];
uint32_t pk_addr[8 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X8(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0U; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<8; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-sha2-128f-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-sha2-128s-simple/avx2/wotsx8.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x8 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8 * 8];
uint32_t pk_addr[8 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X8(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0U; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<8; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-sha2-128s-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-sha2-192f-simple/avx2/wotsx8.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x8 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8 * 8];
uint32_t pk_addr[8 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X8(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0U; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<8; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-sha2-192f-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-sha2-192s-simple/avx2/wotsx8.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x8 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8 * 8];
uint32_t pk_addr[8 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X8(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0U; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<8; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-sha2-192s-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-sha2-256f-simple/avx2/wotsx8.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x8 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8 * 8];
uint32_t pk_addr[8 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X8(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0U; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<8; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-sha2-256f-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-sha2-256s-simple/avx2/wotsx8.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x8 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8 * 8];
uint32_t pk_addr[8 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X8(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0U; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<8; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-sha2-256s-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-shake-128f-simple/aarch64/wotsx2.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x2 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[2 * 8];
uint32_t pk_addr[2 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X2(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<2; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-128f-simple/avx2/wotsx4.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x4 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[4 * 8];
uint32_t pk_addr[4 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X4(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<4; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-128f-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-shake-128s-simple/aarch64/wotsx2.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x2 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[2 * 8];
uint32_t pk_addr[2 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X2(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<2; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-128s-simple/avx2/wotsx4.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x4 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[4 * 8];
uint32_t pk_addr[4 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X4(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<4; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-128s-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-shake-192f-simple/aarch64/wotsx2.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x2 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[2 * 8];
uint32_t pk_addr[2 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X2(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<2; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-192f-simple/avx2/wotsx4.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x4 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[4 * 8];
uint32_t pk_addr[4 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X4(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<4; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-192f-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-shake-192s-simple/aarch64/wotsx2.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x2 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[2 * 8];
uint32_t pk_addr[2 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X2(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<2; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-192s-simple/avx2/wotsx4.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x4 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[4 * 8];
uint32_t pk_addr[4 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X4(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<4; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
pqclean/crypto_sign/sphincs-shake-192s-simple/clean/wotsx1.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x1 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[8];
uint32_t pk_addr[8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X1(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
memcpy( &(info).leaf_addr[0], (addr), 32 ); \
memcpy( &(info).pk_addr[0], (addr), 32 ); \
}
pqclean/crypto_sign/sphincs-shake-256f-simple/aarch64/wotsx2.h view on Meta::CPAN
* the performance
*/
struct leaf_info_x2 {
unsigned char *wots_sig;
uint32_t wots_sign_leaf; /* The index of the WOTS we're using to sign */
uint32_t *wots_steps;
uint32_t leaf_addr[2 * 8];
uint32_t pk_addr[2 * 8];
};
/* Macro to set the leaf_info to something 'benign', that is, it would */
/* run with the same time as it does during the real signing process */
/* Used only by the benchmark code */
#define INITIALIZE_LEAF_INFO_X2(info, addr, step_buffer) { \
(info).wots_sig = 0; \
(info).wots_sign_leaf = ~0; \
(info).wots_steps = step_buffer; \
int i; \
for (i=0; i<2; i++) { \
memcpy( &(info).leaf_addr[8*i], addr, 32 ); \
memcpy( &(info).pk_addr[8*i], addr, 32 ); \
( run in 0.894 second using v1.01-cache-2.11-cpan-49f99fa48dc )