Lines Matching defs:Size
333 /* lets export the key, set x to the size of the
342 * the size of the output */
351 In the above example if the size of the RSA public key was more than 1024 bytes this function would return an error code
355 As of v1.13, most functions will update your length on failure to indicate the size required by the function. Not all functions
393 for a chaining mode or public key packet it is assumed that regardless of the actual size of \textit{unsigned char} only the
443 These two functions will encrypt or decrypt (respectively) a single block of text\footnote{The size of which depends on
459 For each cipher there is a function which will help find a desired key size. It is specified as follows:
464 Essentially, it will round the input keysize in \textit{keysize} down to the next appropriate key size. This function
465 will return {\bf CRYPT\_OK} if the key size specified is acceptable. For example:
476 printf("Error getting key size: %s\n", error_to_string(err));
479 printf("Twofish suggested a key size of %d\n", keysize);
556 size.
578 /** block size (octets) */
589 are the minimum and maximum key sizes in bytes. The \textit{block\_length} member is the block size of the cipher
609 \hline \textbf{Name} & \textbf{Descriptor Name} & \textbf{Block Size} & \textbf{Key Range} & \textbf{Rounds} \\
767 size of the cipher. Given a key $k$, a plaintext $P$ and a cipher $E$ we shall denote the encryption of the block
796 Where $W$ is the size of a block in bits (e.g. 64 for Blowfish). As long as the initial vector is random for each message
807 Note that in this library the output feedback width is equal to the size of the block cipher. That is this mode is used
828 \item Allows the encryption of block sizes that are not equal to the size of the block cipher.
830 The CTR, CFB and OFB routines provided allow you to encrypt block sizes that differ from the ciphers block size. They
831 accomplish this by buffering the data required to complete a block. This allows you to encrypt or decrypt any size
834 The ECB and CBC modes process blocks of the same size as the cipher at a time. Therefore, they are less flexible than the
877 length as the block size\footnote{In other words the size of a block of plaintext for the cipher, e.g. 8 for DES, 16 for AES, etc.}
908 In all cases, \textit{len} is the size of the buffer (as number of octets) to encrypt or decrypt. The CTR, OFB and CFB modes are order sensitive but not
913 In the ECB and CBC cases, \textit{len} must be a multiple of the ciphers block size. In the CBC case, you must manually pad the end of your message (either with
934 of the IV passed in must be the size of the ciphers block size.
1131 of the ciphers block size.
1277 sizeof(pt) /* size of plaintext */
1347 block size (e.g. 16 bytes for AES).
1364 They assume that \textit{pt} and \textit{ct} are the same size as the block cipher's block size. Note that you cannot call
1386 Note that \textit{ptlen} must be less than or equal to the block size of block cipher chosen. Also note that if you have
1387 an input message equal to the length of the block size then you pass the data here (not to ocb\_encrypt()) only.
1458 16--byte block size for CCM.
1560 chosen must have a 16--byte block size (e.g., AES).
1823 unsigned long hashsize; /* digest output size in bytes */
1824 unsigned long blocksize; /* the block size the hash uses */
1839 The \textit{name} member is the name of the hash function (all lowercase). The \textit{hashsize} member is the size of the digest output
1840 in bytes, while \textit{blocksize} is the size of blocks the hash expects to the compression function. Technically, this detail is not important
1901 length. This provides a simple size you can set your automatic arrays to that will not get overrun.
1916 digest is stored in \textit{out}, and the \textit{outlen} parameter is updated to hold the message digest size.
1929 when it is called. The message digest is stored in \textit{out}, and the \textit{outlen} parameter is updated to hold the message digest size.
1941 when it is called. The message digest is stored in \textit{out}, and the \textit{outlen} parameter is updated to hold the message digest size.
1990 \hline \textbf{Name} & \textbf{Descriptor Name} & \textbf{Size of Message Digest (bytes)} \\
2033 \item The cipher must have a block size greater than 64--bits.
2034 \item The cipher must allow an input key the size of the block size.
2111 You must set \textit{outlen} to the size of the destination buffer before calling this function. It is updated with the length of the HMAC code
2112 produced (depending on which hash was picked). If \textit{outlen} is less than the size of the message digest (and ultimately
2130 to the size of the destination buffer before calling this function. Similarly for files there is the following function:
2214 of the cipher\footnote{The cipher must have a 64 or 128 bit block size. Such as CAST5, Blowfish, DES, AES, Twofish, etc.} you
2247 \textit{outlen} can be smaller than the default MAC size (for instance AES would make a 16-byte tag). Part of the OMAC
2249 the output MAC code will only be five bytes long. If \textit{outlen} is larger than the default size it is set to the default
2250 size to show how many bytes were actually used.
2351 must have a 64 or 128 bit block size (e.x. AES).
2384 than the size of the tag it is set to the amount of bytes stored in \textit{out}.
2536 specifies the maximum size of the destination buffer, and is updated to hold the final size of the tag when the function returns. This will return \textbf{CRYPT\_OK} on success.
2581 bit followed by a 1 bit and enough zeros to make the message a multiple of the cipher block size. If the message is byte aligned, the padding takes on the form of
2621 specifies the maximum size of the destination buffer, and is updated to hold the final size of the tag when the function returns. This will return
2801 int export_size; /* size in bytes of exported state */
3084 longer than the modulus which helps allocate the correct output buffer size.
3133 OAEP encoding requires the length of the modulus in bits in order to calculate the size of the output. This is passed as the parameter
3135 used but both the encoder and decoder must use the same hash in order for this to succeed. The size of hash output affects the maximum
3163 match what was used during encoding this function will not decode the packet. \textit{modulus\_bitlen} is the size of the RSA modulus in bits
3195 Similar to OAEP encoding \textit{modulus\_bitlen} is the size of the RSA modulus (in bits). It limits the size of the salt. If $m$ is the length
3260 int size,
3265 Where \textit{wprng} is the index into the PRNG descriptor array. The \textit{size} parameter is the size in bytes of the RSA modulus desired.
3268 least 128 bytes, and no more than 512 bytes in size (\textit{that is from 1024 to 4096 bits}).
3293 in \textit{out} and the size of the result in \textit{outlen}. \textit{which} is set to {\bf PK\_PUBLIC} to use \textit{e}
3413 default value is between 8 and 16 octets. Strictly, it must be small than $modulus\_len - hLen - 2$ where \textit{modulus\_len} is the size of
3623 range in order from $\approx 2^{112}$ points to $\approx 2^{521}$. According to the source document any key size greater
3640 The optimization works by using a Fixed Point multiplier on any base point you use twice or more in a short period of time. It has a limited size
3671 keySize INTEGER, -- Curve size (in bits) divided by eight
3679 keySize INTEGER, -- Curve size (in bits) divided by eight
3700 /** The size of the curve in octets */
3701 int size;
3736 The \textit{keysize} is the size of the modulus in bytes desired. Currently directly supported values are 12, 16, 20, 24, 28, 32, 48, and 65 bytes which
3737 correspond to key sizes of 112, 128, 160, 192, 224, 256, 384, and 521 bits respectively. If you pass a key size that is between any key size it will round
3945 work. With ECC keys the strength of the signature is limited by the size of the hash, or the size of they key, whichever is smaller. For example, if you sign with
4086 Which will sign the data in \textit{in} of length \textit{inlen} bytes. The signature is stored in \textit{out} and the size
4087 of the signature in \textit{outlen}. If the signature is longer than the size you initially specify in \textit{outlen} nothing
4154 initialized to the maximum buffer size). The \textit{type} variable may be either \textbf{PK\_PRIVATE} or \textbf{PK\_PUBLIC}
4184 unsigned long size;
4193 \textit{size} field is specific to what you are encoding (e.g. number of bits in the BIT STRING data type). The \textit{used} field is primarily for the CHOICE decoder
4195 \textit{LTC\_SET\_ASN1(list, index, Type, Data, Size)} has been provided.
4197 It will assign to the \textit{index}th position in the \textit{list} the triplet (Type, Data, Size). An example usage would be:
4278 Decoding a SEQUENCE is similar to encoding. You set up an array of \textbf{ltc\_asn1\_list} where in this case the \textit{size} member is the maximum size
4279 (in certain cases). For types such as IA5 STRING, BIT STRING, OCTET STRING (etc) the \textit{size} field is updated after successful decoding to reflect how many
4292 For the following types the \textit{size} field will be updated to reflect the number of units read of the given type.
4312 This will get the encoding size for the given \textit{list} of length \textit{inlen} and store it in \textit{outlen}.
4331 The list of items are specified as a triple of the form \textit{(type, size, data)} where \textit{type} is an \textbf{int}, \textit{size} is a \textbf{unsigned long}
4334 It is ideal that you cast the \textit{size} values to unsigned long to ensure that the proper data type is passed to the function. Constants such as \textit{1} without
4355 on the size parameters. This forces the compiler to pass the numbers as the required \textbf{unsigned long} type that the function expects.
4730 Now \textit{list} points to the \textit{Name} member (with the tag IA5 STRING). The \textit{data}, \textit{size}, and \textit{type} members of \textit{list} should reflect
4786 The \textit{salt} is a fixed size 8--byte array which should be random for each user and session. The \textit{iteration\_count} is the delay desired
4789 The output of length up to \textit{outlen} is stored in \textit{out}. If \textit{outlen} is initially larger than the size of the hash functions output
4810 The \textit{salt} is an array of size \textit{salt\_len}. It should be random for each user and session. The \textit{iteration\_count} is the delay desired
4917 Where \textit{len} is the size of the prime in bytes ($2 \le len \le 256$). You can set \textit{len} to the negative size you want
4936 which output variable length strings will require you to pass the length of the destination. If the size of your output
4937 buffer is smaller than the output it will report an error. Therefore, make sure the size you pass is correct!
4969 \hline RSA/DH Key Size (bits) & Work Factor ($log_2$) \\
4989 \hline ECC Key Size (bits) & Work Factor ($log_2$) \\
5007 \hline Security Goal & RSA/DH Key Size (bits) & ECC Key Size (bits) \\
5206 platforms define \textbf{ENDIAN\_BIG}. Similarly when the default word size of an \textit{unsigned long} is 32-bits define \textbf{ENDIAN\_32BITWORD}
5268 data type you can perform integer operations with. Ideally it should be four or eight bytes since it must properly divide the size
5297 useful when TWOFISH\_SMALL is defined as the table values are computed on the fly. When this is defined the code size
5378 /** block size (octets) */
5427 /** Determine a key size
5428 @param keysize [in/out] The size of the key desired
5429 The suggested size
5547 @param taglen [in/out] The max size and resulting size
5592 @param outlen [in/out] Initial and final size of out
5606 @param outlen [in/out] Initial and final size of out
5620 @param outlen [in/out] Initial and final size of out
5645 The size of the ciphers plaintext or ciphertext is \textit{block\_length} and is measured in octets.
5667 Occasionally, a function will want to find a suitable key size to use since the input is oddly sized. The keysize() function is for this case. It accepts a
5668 pointer to an integer which represents the desired size. The function then has to match it to the exact or a lower key size
5670 cannot be mapped to a valid key size for the cipher.
5691 This function (and the way it's called) differs from the other two since ctr\_encrypt() allows any size input plaintext. The accelerator will only be
5697 \item The remaining length of the input to process is greater than or equal to the block size.
5769 /** Size of digest in octets */
5772 /** Input block size in octets */
5831 \subsection{Digest Size}
5834 \subsection{Block Size}
5846 guaranteed to be a multiple of the block size in length.
5867 /** size in bytes of exported state */
5910 @param outlen [in/out] The max size and resulting size
5940 \subsection{Export Size}
6091 /** get size as unsigned char string
6092 @param a The integer to get the size
6363 @param size The size of the key in octets
6371 int size,
6379 @param outlen The length of the output buffer and the resulting size
6380 (zero padded to the size of the modulus)
6405 then partition your digits. Normally this does not matter as \textit{unsigned long} will be the same size as your register size. Note that if your digit is smaller
