Mbed TLS v4.1.1
Toggle main menu visibility
Loading...
Searching...
No Matches
crypto_sizes.h
Go to the documentation of this file.
1
23
/*
24
* Copyright The Mbed TLS Contributors
25
* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
26
*/
27
28
#ifndef PSA_CRYPTO_SIZES_H
29
#define PSA_CRYPTO_SIZES_H
30
31
#include "
tf-psa-crypto/build_info.h
"
32
33
#define PSA_BITS_TO_BYTES(bits) (((bits) + 7u) / 8u)
34
#define PSA_BYTES_TO_BITS(bytes) ((bytes) * 8u)
35
#define PSA_MAX_OF_THREE(a, b, c) ((a) <= (b) ? (b) <= (c) ? \
36
(c) : (b) : (a) <= (c) ? (c) : (a))
37
38
#define PSA_ROUND_UP_TO_MULTIPLE(block_size, length) \
39
(((length) + (block_size) - 1) / (block_size) * (block_size))
40
53
#define PSA_HASH_LENGTH(alg) \
54
( \
55
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD5 ? 16u : \
56
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_RIPEMD160 ? 20u : \
57
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_1 ? 20u : \
58
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_224 ? 28u : \
59
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_256 ? 32u : \
60
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_384 ? 48u : \
61
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512 ? 64u : \
62
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_224 ? 28u : \
63
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_256 ? 32u : \
64
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_224 ? 28u : \
65
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_256 ? 32u : \
66
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_384 ? 48u : \
67
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_512 ? 64u : \
68
0u)
69
85
#define PSA_HASH_BLOCK_LENGTH(alg) \
86
( \
87
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD5 ? 64u : \
88
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_RIPEMD160 ? 64u : \
89
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_1 ? 64u : \
90
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_224 ? 64u : \
91
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_256 ? 64u : \
92
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_384 ? 128u : \
93
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512 ? 128u : \
94
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_224 ? 128u : \
95
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_256 ? 128u : \
96
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_224 ? 144u : \
97
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_256 ? 136u : \
98
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_384 ? 104u : \
99
PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_512 ? 72u : \
100
0u)
101
109
/* Note: for HMAC-SHA-3, the block size is 144 bytes for HMAC-SHA3-224,
110
* 136 bytes for HMAC-SHA3-256, 104 bytes for SHA3-384, 72 bytes for
111
* HMAC-SHA3-512. */
112
/* Note: PSA_HASH_MAX_SIZE should be kept in sync with MBEDTLS_MD_MAX_SIZE,
113
* see the note on MBEDTLS_MD_MAX_SIZE for details. */
114
#if defined(PSA_WANT_ALG_SHA3_224)
115
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 144u
116
#elif defined(PSA_WANT_ALG_SHA3_256)
117
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 136u
118
#elif defined(PSA_WANT_ALG_SHA_512)
119
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 128u
120
#elif defined(PSA_WANT_ALG_SHA_384)
121
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 128u
122
#elif defined(PSA_WANT_ALG_SHA3_384)
123
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 104u
124
#elif defined(PSA_WANT_ALG_SHA3_512)
125
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 72u
126
#elif defined(PSA_WANT_ALG_SHA_256)
127
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 64u
128
#elif defined(PSA_WANT_ALG_SHA_224)
129
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 64u
130
#else
/* SHA-1 or smaller */
131
#define PSA_HMAC_MAX_HASH_BLOCK_SIZE 64u
132
#endif
133
134
#if defined(PSA_WANT_ALG_SHA_512) || defined(PSA_WANT_ALG_SHA3_512)
135
#define PSA_HASH_MAX_SIZE 64u
136
#elif defined(PSA_WANT_ALG_SHA_384) || defined(PSA_WANT_ALG_SHA3_384)
137
#define PSA_HASH_MAX_SIZE 48u
138
#elif defined(PSA_WANT_ALG_SHA_256) || defined(PSA_WANT_ALG_SHA3_256)
139
#define PSA_HASH_MAX_SIZE 32u
140
#elif defined(PSA_WANT_ALG_SHA_224) || defined(PSA_WANT_ALG_SHA3_224)
141
#define PSA_HASH_MAX_SIZE 28u
142
#else
/* SHA-1 or smaller */
143
#define PSA_HASH_MAX_SIZE 20u
144
#endif
145
153
/* All non-HMAC MACs have a maximum size that's smaller than the
154
* minimum possible value of PSA_HASH_MAX_SIZE in this implementation. */
155
/* Note that the encoding of truncated MAC algorithms limits this value
156
* to 64 bytes.
157
*/
158
#define PSA_MAC_MAX_SIZE PSA_HASH_MAX_SIZE
159
181
#define PSA_AEAD_TAG_LENGTH(key_type, key_bits, alg) \
182
(PSA_AEAD_NONCE_LENGTH(key_type, alg) != 0 ? \
183
PSA_ALG_AEAD_GET_TAG_LENGTH(alg) : \
184
((void) (key_bits), 0u))
185
190
#define PSA_AEAD_TAG_MAX_SIZE 16u
191
192
/* The maximum size of an RSA key on this implementation, in bits.
193
* This is a vendor-specific macro.
194
*
195
* Mbed TLS does not set a hard limit on the size of RSA keys: any key
196
* whose parameters fit in a bignum is accepted. However large keys can
197
* induce a large memory usage and long computation times. Unlike other
198
* auxiliary macros in this file and in crypto.h, which reflect how the
199
* library is configured, this macro defines how the library is
200
* configured. This implementation refuses to import or generate an
201
* RSA key whose size is larger than the value defined here.
202
*
203
* Note that an implementation may set different size limits for different
204
* operations, and does not need to accept all key sizes up to the limit. */
205
#define PSA_VENDOR_RSA_MAX_KEY_BITS 4096u
206
207
/* The minimum size of an RSA key on this implementation, in bits.
208
* This is a vendor-specific macro.
209
*
210
* Limits RSA key generation to a minimum due to avoid accidental misuse.
211
* This value cannot be less than 128 bits.
212
*/
213
#if defined(MBEDTLS_RSA_GEN_KEY_MIN_BITS)
214
#define PSA_VENDOR_RSA_GENERATE_MIN_KEY_BITS MBEDTLS_RSA_GEN_KEY_MIN_BITS
215
#else
216
#define PSA_VENDOR_RSA_GENERATE_MIN_KEY_BITS 1024
217
#endif
218
219
/* The maximum size of an DH key on this implementation, in bits.
220
* This is a vendor-specific macro.*/
221
#if defined(PSA_WANT_DH_RFC7919_8192)
222
#define PSA_VENDOR_FFDH_MAX_KEY_BITS 8192u
223
#elif defined(PSA_WANT_DH_RFC7919_6144)
224
#define PSA_VENDOR_FFDH_MAX_KEY_BITS 6144u
225
#elif defined(PSA_WANT_DH_RFC7919_4096)
226
#define PSA_VENDOR_FFDH_MAX_KEY_BITS 4096u
227
#elif defined(PSA_WANT_DH_RFC7919_3072)
228
#define PSA_VENDOR_FFDH_MAX_KEY_BITS 3072u
229
#elif defined(PSA_WANT_DH_RFC7919_2048)
230
#define PSA_VENDOR_FFDH_MAX_KEY_BITS 2048u
231
#else
232
#define PSA_VENDOR_FFDH_MAX_KEY_BITS 0u
233
#endif
234
235
/* The maximum size of an ECC key on this implementation, in bits.
236
* This is a vendor-specific macro. */
237
#if defined(PSA_WANT_ECC_SECP_R1_521)
238
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 521u
239
#elif defined(PSA_WANT_ECC_BRAINPOOL_P_R1_512)
240
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 512u
241
#elif defined(PSA_WANT_ECC_MONTGOMERY_448)
242
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 448u
243
#elif defined(PSA_WANT_ECC_SECP_R1_384)
244
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 384u
245
#elif defined(PSA_WANT_ECC_BRAINPOOL_P_R1_384)
246
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 384u
247
#elif defined(PSA_WANT_ECC_SECP_R1_256)
248
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 256u
249
#elif defined(PSA_WANT_ECC_SECP_K1_256)
250
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 256u
251
#elif defined(PSA_WANT_ECC_BRAINPOOL_P_R1_256)
252
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 256u
253
#elif defined(PSA_WANT_ECC_MONTGOMERY_255)
254
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 255u
255
#else
256
#define PSA_VENDOR_ECC_MAX_CURVE_BITS 0u
257
#endif
258
274
#define PSA_TLS12_PSK_TO_MS_PSK_MAX_SIZE 128u
275
276
/* The expected size of input passed to psa_tls12_ecjpake_to_pms_input,
277
* which is expected to work with P-256 curve only. */
278
#define PSA_TLS12_ECJPAKE_TO_PMS_INPUT_SIZE 65u
279
280
/* The size of a serialized K.X coordinate to be used in
281
* psa_tls12_ecjpake_to_pms_input. This function only accepts the P-256
282
* curve. */
283
#define PSA_TLS12_ECJPAKE_TO_PMS_DATA_SIZE 32u
284
285
/* The maximum number of iterations for PBKDF2 on this implementation, in bits.
286
* This is a vendor-specific macro. This can be configured if necessary */
287
#define PSA_VENDOR_PBKDF2_MAX_ITERATIONS 0xffffffffU
288
290
#define PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE 16u
291
313
#define PSA_MAC_LENGTH(key_type, key_bits, alg) \
314
(((alg) & PSA_ALG_MAC_TRUNCATION_MASK) ? PSA_MAC_TRUNCATED_LENGTH(alg) : \
315
PSA_ALG_IS_HMAC(alg) ? PSA_HASH_LENGTH(PSA_ALG_HMAC_GET_HASH(alg)) : \
316
PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) ? PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) : \
317
((void) (key_type), (void) (key_bits), 0u))
318
345
#define PSA_AEAD_ENCRYPT_OUTPUT_SIZE(key_type, alg, plaintext_length) \
346
(PSA_AEAD_NONCE_LENGTH(key_type, alg) != 0 ? \
347
(plaintext_length) + PSA_ALG_AEAD_GET_TAG_LENGTH(alg) : \
348
0u)
349
368
#define PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(plaintext_length) \
369
((plaintext_length) + PSA_AEAD_TAG_MAX_SIZE)
370
371
398
#define PSA_AEAD_DECRYPT_OUTPUT_SIZE(key_type, alg, ciphertext_length) \
399
(PSA_AEAD_NONCE_LENGTH(key_type, alg) != 0 && \
400
(ciphertext_length) > PSA_ALG_AEAD_GET_TAG_LENGTH(alg) ? \
401
(ciphertext_length) - PSA_ALG_AEAD_GET_TAG_LENGTH(alg) : \
402
0u)
403
422
#define PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE(ciphertext_length) \
423
(ciphertext_length)
424
450
#define PSA_AEAD_NONCE_LENGTH(key_type, alg) \
451
(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) == 16 ? \
452
MBEDTLS_PSA_ALG_AEAD_EQUAL(alg, PSA_ALG_CCM) ? 13u : \
453
MBEDTLS_PSA_ALG_AEAD_EQUAL(alg, PSA_ALG_GCM) ? 12u : \
454
0u : \
455
(key_type) == PSA_KEY_TYPE_CHACHA20 && \
456
MBEDTLS_PSA_ALG_AEAD_EQUAL(alg, PSA_ALG_CHACHA20_POLY1305) ? 12u : \
457
0u)
458
470
#define PSA_AEAD_NONCE_MAX_SIZE 13u
471
498
/* For all the AEAD modes defined in this specification, it is possible
499
* to emit output without delay. However, hardware may not always be
500
* capable of this. So for modes based on a block cipher, allow the
501
* implementation to delay the output until it has a full block. */
502
#define PSA_AEAD_UPDATE_OUTPUT_SIZE(key_type, alg, input_length) \
503
(PSA_AEAD_NONCE_LENGTH(key_type, alg) != 0 ? \
504
PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) ? \
505
PSA_ROUND_UP_TO_MULTIPLE(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type), (input_length)) : \
506
(input_length) : \
507
0u)
508
519
#define PSA_AEAD_UPDATE_OUTPUT_MAX_SIZE(input_length) \
520
(PSA_ROUND_UP_TO_MULTIPLE(PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE, (input_length)))
521
543
#define PSA_AEAD_FINISH_OUTPUT_SIZE(key_type, alg) \
544
(PSA_AEAD_NONCE_LENGTH(key_type, alg) != 0 && \
545
PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) ? \
546
PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) : \
547
0u)
548
554
#define PSA_AEAD_FINISH_OUTPUT_MAX_SIZE (PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE)
555
577
#define PSA_AEAD_VERIFY_OUTPUT_SIZE(key_type, alg) \
578
(PSA_AEAD_NONCE_LENGTH(key_type, alg) != 0 && \
579
PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) ? \
580
PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) : \
581
0u)
582
588
#define PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE (PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE)
589
590
#define PSA_RSA_MINIMUM_PADDING_SIZE(alg) \
591
(PSA_ALG_IS_RSA_OAEP(alg) ? \
592
2u * PSA_HASH_LENGTH(PSA_ALG_RSA_OAEP_GET_HASH(alg)) + 1u : \
593
11u
/*PKCS#1v1.5*/
)
594
603
#define PSA_ECDSA_SIGNATURE_SIZE(curve_bits) \
604
(PSA_BITS_TO_BYTES(curve_bits) * 2u)
605
631
#define PSA_SIGN_OUTPUT_SIZE(key_type, key_bits, alg) \
632
(PSA_KEY_TYPE_IS_RSA(key_type) ? ((void) alg, PSA_BITS_TO_BYTES(key_bits)) : \
633
PSA_KEY_TYPE_IS_ECC(key_type) ? PSA_ECDSA_SIGNATURE_SIZE(key_bits) : \
634
((void) alg, 0u))
635
636
#define PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE \
637
PSA_ECDSA_SIGNATURE_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS)
638
646
#define PSA_SIGNATURE_MAX_SIZE 1
647
648
#if (defined(PSA_WANT_ALG_ECDSA) || defined(PSA_WANT_ALG_DETERMINISTIC_ECDSA)) && \
649
(PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE > PSA_SIGNATURE_MAX_SIZE)
650
#undef PSA_SIGNATURE_MAX_SIZE
651
#define PSA_SIGNATURE_MAX_SIZE PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE
652
#endif
653
#if (defined(PSA_WANT_ALG_RSA_PKCS1V15_SIGN) || defined(PSA_WANT_ALG_RSA_PSS)) && \
654
(PSA_BITS_TO_BYTES(PSA_VENDOR_RSA_MAX_KEY_BITS) > PSA_SIGNATURE_MAX_SIZE)
655
#undef PSA_SIGNATURE_MAX_SIZE
656
#define PSA_SIGNATURE_MAX_SIZE PSA_BITS_TO_BYTES(PSA_VENDOR_RSA_MAX_KEY_BITS)
657
#endif
658
684
#define PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg) \
685
(PSA_KEY_TYPE_IS_RSA(key_type) ? \
686
((void) alg, PSA_BITS_TO_BYTES(key_bits)) : \
687
0u)
688
694
/* This macro assumes that RSA is the only supported asymmetric encryption. */
695
#define PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE \
696
(PSA_BITS_TO_BYTES(PSA_VENDOR_RSA_MAX_KEY_BITS))
697
723
#define PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(key_type, key_bits, alg) \
724
(PSA_KEY_TYPE_IS_RSA(key_type) ? \
725
PSA_BITS_TO_BYTES(key_bits) - PSA_RSA_MINIMUM_PADDING_SIZE(alg) : \
726
0u)
727
735
#define PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE \
736
(PSA_BITS_TO_BYTES(PSA_VENDOR_RSA_MAX_KEY_BITS))
737
738
/* Maximum size of the ASN.1 encoding of an INTEGER with the specified
739
* number of bits.
740
*
741
* This definition assumes that bits <= 2^19 - 9 so that the length field
742
* is at most 3 bytes. The length of the encoding is overestimated as follows:
743
*
744
* - Take int(bits / 8) as the number of full bytes taken by the value.
745
* - Add 1 extra byte, to account for either:
746
* - A leading-zero byte, needed if the top bit of the value is 1
747
* and bits % 8 == 0 (encoding in two's complement)
748
* - Extra bits, when bits % 8 != 0
749
* - Add 1 type byte
750
* - Add 3 length bytes
751
*/
752
#define PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(bits) \
753
((bits) / 8u + 5u)
754
755
/* Maximum size of the export encoding of an RSA public key.
756
* Assumes that the public exponent is less than 2^32.
757
*
758
* RSAPublicKey ::= SEQUENCE {
759
* modulus INTEGER, -- n
760
* publicExponent INTEGER } -- e
761
*
762
* - 4 bytes of SEQUENCE overhead;
763
* - n : INTEGER;
764
* - 7 bytes for the public exponent.
765
*/
766
#define PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) \
767
(PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) + 11u)
768
769
/* Maximum size of the export encoding of an RSA key pair.
770
* Assumes that the public exponent is less than 2^32 and that the size
771
* difference between the two primes is at most 1 bit.
772
*
773
* RSAPrivateKey ::= SEQUENCE {
774
* version Version, -- 0
775
* modulus INTEGER, -- N-bit
776
* publicExponent INTEGER, -- 32-bit
777
* privateExponent INTEGER, -- N-bit
778
* prime1 INTEGER, -- N/2-bit
779
* prime2 INTEGER, -- N/2-bit
780
* exponent1 INTEGER, -- N/2-bit
781
* exponent2 INTEGER, -- N/2-bit
782
* coefficient INTEGER, -- N/2-bit
783
* }
784
*
785
* - 4 bytes of SEQUENCE overhead;
786
* - 3 bytes of version;
787
* - 5 half-size INTEGERs plus 2 full-size INTEGERs,
788
* overapproximated as 9 half-size INTEGERS;
789
* - 7 bytes for the public exponent.
790
*/
791
#define PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE(key_bits) \
792
(9u * PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE((key_bits) / 2u + 1u) + 14u)
793
794
/* Maximum size of the export encoding of a DSA public key.
795
*
796
* SubjectPublicKeyInfo ::= SEQUENCE {
797
* algorithm AlgorithmIdentifier,
798
* subjectPublicKey BIT STRING } -- contains DSAPublicKey
799
* AlgorithmIdentifier ::= SEQUENCE {
800
* algorithm OBJECT IDENTIFIER,
801
* parameters Dss-Params } -- SEQUENCE of 3 INTEGERs
802
* DSAPublicKey ::= INTEGER -- public key, Y
803
*
804
* - 3 * 4 bytes of SEQUENCE overhead;
805
* - 1 + 1 + 7 bytes of algorithm (DSA OID);
806
* - 4 bytes of BIT STRING overhead;
807
* - 3 full-size INTEGERs (p, g, y);
808
* - 1 + 1 + 32 bytes for 1 sub-size INTEGER (q <= 256 bits).
809
*/
810
#define PSA_KEY_EXPORT_DSA_PUBLIC_KEY_MAX_SIZE(key_bits) \
811
(PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3u + 59u)
812
813
/* Maximum size of the export encoding of a DSA key pair.
814
*
815
* DSAPrivateKey ::= SEQUENCE {
816
* version Version, -- 0
817
* prime INTEGER, -- p
818
* subprime INTEGER, -- q
819
* generator INTEGER, -- g
820
* public INTEGER, -- y
821
* private INTEGER, -- x
822
* }
823
*
824
* - 4 bytes of SEQUENCE overhead;
825
* - 3 bytes of version;
826
* - 3 full-size INTEGERs (p, g, y);
827
* - 2 * (1 + 1 + 32) bytes for 2 sub-size INTEGERs (q, x <= 256 bits).
828
*/
829
#define PSA_KEY_EXPORT_DSA_KEY_PAIR_MAX_SIZE(key_bits) \
830
(PSA_KEY_EXPORT_ASN1_INTEGER_MAX_SIZE(key_bits) * 3u + 75u)
831
832
/* Maximum size of the export encoding of an ECC public key.
833
*
834
* The representation of an ECC public key is:
835
* - The byte 0x04;
836
* - `x_P` as a `ceiling(m/8)`-byte string, big-endian;
837
* - `y_P` as a `ceiling(m/8)`-byte string, big-endian;
838
* - where m is the bit size associated with the curve.
839
*
840
* - 1 byte + 2 * point size.
841
*/
842
#define PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) \
843
(2u * PSA_BITS_TO_BYTES(key_bits) + 1u)
844
845
/* Maximum size of the export encoding of an ECC key pair.
846
*
847
* An ECC key pair is represented by the secret value.
848
*/
849
#define PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(key_bits) \
850
(PSA_BITS_TO_BYTES(key_bits))
851
852
/* Maximum size of the export encoding of an DH key pair.
853
*
854
* An DH key pair is represented by the secret value.
855
*/
856
#define PSA_KEY_EXPORT_FFDH_KEY_PAIR_MAX_SIZE(key_bits) \
857
(PSA_BITS_TO_BYTES(key_bits))
858
859
/* Maximum size of the export encoding of an DH public key.
860
*/
861
#define PSA_KEY_EXPORT_FFDH_PUBLIC_KEY_MAX_SIZE(key_bits) \
862
(PSA_BITS_TO_BYTES(key_bits))
863
903
#define PSA_EXPORT_KEY_OUTPUT_SIZE(key_type, key_bits) \
904
((key_type) == PSA_KEY_TYPE_RSA_KEY_PAIR ? PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE(key_bits) : \
905
(key_type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY ? PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) : \
906
PSA_KEY_TYPE_IS_ECC_KEY_PAIR(key_type) ? PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(key_bits) : \
907
PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(key_type) ? PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) : \
908
PSA_BITS_TO_BYTES(key_bits))
/*unstructured; FFDH public or private*/
909
955
#define PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(key_type, key_bits) \
956
(PSA_KEY_TYPE_IS_RSA(key_type) ? PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(key_bits) : \
957
PSA_KEY_TYPE_IS_ECC(key_type) ? PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits) : \
958
PSA_KEY_TYPE_IS_DH(key_type) ? PSA_BITS_TO_BYTES(key_bits) : \
959
0u)
960
969
#define PSA_EXPORT_KEY_PAIR_MAX_SIZE 1
970
971
#if defined(PSA_WANT_KEY_TYPE_ECC_KEY_PAIR_BASIC) && \
972
(PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS) > \
973
PSA_EXPORT_KEY_PAIR_MAX_SIZE)
974
#undef PSA_EXPORT_KEY_PAIR_MAX_SIZE
975
#define PSA_EXPORT_KEY_PAIR_MAX_SIZE \
976
PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS)
977
#endif
978
#if defined(PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_BASIC) && \
979
(PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE(PSA_VENDOR_RSA_MAX_KEY_BITS) > \
980
PSA_EXPORT_KEY_PAIR_MAX_SIZE)
981
#undef PSA_EXPORT_KEY_PAIR_MAX_SIZE
982
#define PSA_EXPORT_KEY_PAIR_MAX_SIZE \
983
PSA_KEY_EXPORT_RSA_KEY_PAIR_MAX_SIZE(PSA_VENDOR_RSA_MAX_KEY_BITS)
984
#endif
985
#if defined(PSA_WANT_KEY_TYPE_DH_KEY_PAIR_BASIC) && \
986
(PSA_KEY_EXPORT_FFDH_KEY_PAIR_MAX_SIZE(PSA_VENDOR_FFDH_MAX_KEY_BITS) > \
987
PSA_EXPORT_KEY_PAIR_MAX_SIZE)
988
#undef PSA_EXPORT_KEY_PAIR_MAX_SIZE
989
#define PSA_EXPORT_KEY_PAIR_MAX_SIZE \
990
PSA_KEY_EXPORT_FFDH_KEY_PAIR_MAX_SIZE(PSA_VENDOR_FFDH_MAX_KEY_BITS)
991
#endif
992
1002
#define PSA_EXPORT_PUBLIC_KEY_MAX_SIZE 1
1003
1004
#if defined(PSA_WANT_KEY_TYPE_ECC_PUBLIC_KEY) && \
1005
(PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS) > \
1006
PSA_EXPORT_PUBLIC_KEY_MAX_SIZE)
1007
#undef PSA_EXPORT_PUBLIC_KEY_MAX_SIZE
1008
#define PSA_EXPORT_PUBLIC_KEY_MAX_SIZE \
1009
PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS)
1010
#endif
1011
#if defined(PSA_WANT_KEY_TYPE_RSA_PUBLIC_KEY) && \
1012
(PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_RSA_MAX_KEY_BITS) > \
1013
PSA_EXPORT_PUBLIC_KEY_MAX_SIZE)
1014
#undef PSA_EXPORT_PUBLIC_KEY_MAX_SIZE
1015
#define PSA_EXPORT_PUBLIC_KEY_MAX_SIZE \
1016
PSA_KEY_EXPORT_RSA_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_RSA_MAX_KEY_BITS)
1017
#endif
1018
#if defined(PSA_WANT_KEY_TYPE_DH_PUBLIC_KEY) && \
1019
(PSA_KEY_EXPORT_FFDH_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_FFDH_MAX_KEY_BITS) > \
1020
PSA_EXPORT_PUBLIC_KEY_MAX_SIZE)
1021
#undef PSA_EXPORT_PUBLIC_KEY_MAX_SIZE
1022
#define PSA_EXPORT_PUBLIC_KEY_MAX_SIZE \
1023
PSA_KEY_EXPORT_FFDH_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_FFDH_MAX_KEY_BITS)
1024
#endif
1025
1026
/* This is the name that was standardized in PSA Crypto v1.3 */
1027
#define PSA_EXPORT_ASYMMETRIC_KEY_MAX_SIZE \
1028
((PSA_EXPORT_KEY_PAIR_MAX_SIZE > PSA_EXPORT_PUBLIC_KEY_MAX_SIZE) ? \
1029
PSA_EXPORT_KEY_PAIR_MAX_SIZE : PSA_EXPORT_PUBLIC_KEY_MAX_SIZE)
1030
1054
#define PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE(key_type, key_bits) \
1055
((PSA_KEY_TYPE_IS_ECC_KEY_PAIR(key_type) || \
1056
PSA_KEY_TYPE_IS_DH_KEY_PAIR(key_type)) ? PSA_BITS_TO_BYTES(key_bits) : 0u)
1057
1065
#define PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE 1
1066
1067
#if defined(PSA_WANT_ALG_ECDH) && \
1068
(PSA_BITS_TO_BYTES(PSA_VENDOR_ECC_MAX_CURVE_BITS) > PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE)
1069
#undef PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE
1070
#define PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE PSA_BITS_TO_BYTES(PSA_VENDOR_ECC_MAX_CURVE_BITS)
1071
#endif
1072
#if defined(PSA_WANT_ALG_FFDH) && \
1073
(PSA_BITS_TO_BYTES(PSA_VENDOR_FFDH_MAX_KEY_BITS) > PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE)
1074
#undef PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE
1075
#define PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE PSA_BITS_TO_BYTES(PSA_VENDOR_FFDH_MAX_KEY_BITS)
1076
#endif
1077
1090
#if (defined(PSA_WANT_KEY_TYPE_AES) || defined(PSA_WANT_KEY_TYPE_ARIA) || \
1091
defined(PSA_WANT_KEY_TYPE_CAMELLIA) || defined(PSA_WANT_KEY_TYPE_CHACHA20))
1092
#define PSA_CIPHER_MAX_KEY_LENGTH 32u
1093
#else
1094
#define PSA_CIPHER_MAX_KEY_LENGTH 0u
1095
#endif
1096
1121
#define PSA_CIPHER_IV_LENGTH(key_type, alg) \
1122
(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) > 1 && \
1123
((alg) == PSA_ALG_CTR || \
1124
(alg) == PSA_ALG_CFB || \
1125
(alg) == PSA_ALG_OFB || \
1126
(alg) == PSA_ALG_XTS || \
1127
(alg) == PSA_ALG_CBC_NO_PADDING || \
1128
(alg) == PSA_ALG_CBC_PKCS7) ? PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) : \
1129
(key_type) == PSA_KEY_TYPE_CHACHA20 && \
1130
(alg) == PSA_ALG_STREAM_CIPHER ? 12u : \
1131
(alg) == PSA_ALG_CCM_STAR_NO_TAG ? 13u : \
1132
0u)
1133
1138
#define PSA_CIPHER_IV_MAX_SIZE 16u
1139
1163
#define PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input_length) \
1164
(alg == PSA_ALG_CBC_PKCS7 ? \
1165
(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) != 0 ? \
1166
PSA_ROUND_UP_TO_MULTIPLE(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type), \
1167
(input_length) + 1u) + \
1168
PSA_CIPHER_IV_LENGTH((key_type), (alg)) : 0u) : \
1169
(PSA_ALG_IS_CIPHER(alg) ? \
1170
(input_length) + PSA_CIPHER_IV_LENGTH((key_type), (alg)) : \
1171
0u))
1172
1184
#define PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE(input_length) \
1185
(PSA_ROUND_UP_TO_MULTIPLE(PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE, \
1186
(input_length) + 1u) + \
1187
PSA_CIPHER_IV_MAX_SIZE)
1188
1208
#define PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, input_length) \
1209
(PSA_ALG_IS_CIPHER(alg) && \
1210
((key_type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_SYMMETRIC ? \
1211
(input_length) : \
1212
0u)
1213
1224
#define PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(input_length) \
1225
(input_length)
1226
1245
#define PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input_length) \
1246
(PSA_ALG_IS_CIPHER(alg) ? \
1247
(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) != 0 ? \
1248
(((alg) == PSA_ALG_CBC_PKCS7 || \
1249
(alg) == PSA_ALG_CBC_NO_PADDING || \
1250
(alg) == PSA_ALG_ECB_NO_PADDING) ? \
1251
PSA_ROUND_UP_TO_MULTIPLE(PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type), \
1252
input_length) : \
1253
(input_length)) : 0u) : \
1254
0u)
1255
1266
#define PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(input_length) \
1267
(PSA_ROUND_UP_TO_MULTIPLE(PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE, input_length))
1268
1286
#define PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg) \
1287
(PSA_ALG_IS_CIPHER(alg) ? \
1288
(alg == PSA_ALG_CBC_PKCS7 ? \
1289
PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type) : \
1290
0u) : \
1291
0u)
1292
1298
#define PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE \
1299
(PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE)
1300
1301
#endif
/* PSA_CRYPTO_SIZES_H */
build_info.h
Build-time configuration info.
tf-psa-crypto
include
psa
crypto_sizes.h
Generated on
for Mbed TLS v4.1.1 by
1.17.0