mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-25 01:02:24 +00:00
42120dd1c5
Now those names appear in help files, I thought it was worth giving
them a read-through and spotting any really obviously confusing or
wrong ones. Quite a few make more sense in the original context of C
than in the derived Python (e.g. 'BinarySink *bs' as a place to write
output to makes sense, but the output 'val_string bs' is less
helpful).
A couple were so confusing that I also corrected them in the original
C, notably the misuse of 'wc' for the elliptic curve point input to
ecc_weierstrass_point_copy. ('wc' in that section of the code is
normally a parameter describing a whole curve.)
563 lines
26 KiB
C
563 lines
26 KiB
C
/*
|
|
* List of functions exported by the 'testcrypt' system to provide a
|
|
* Python API for running unit tests and auxiliary programs.
|
|
*
|
|
* Each function definition in this file has the form
|
|
*
|
|
* FUNC(return-type, function-name, (arguments))
|
|
*
|
|
* where 'arguments' in turn is either VOID, or a comma-separated list
|
|
* of argument specifications of the form
|
|
*
|
|
* ARG(argument-type, argument-name)
|
|
*
|
|
* Type names are always single identifiers, and they have some
|
|
* standard prefixes:
|
|
*
|
|
* 'val_' means that the type refers to something dynamically
|
|
* allocated, so that it has a persistent identity, needs to be freed
|
|
* when finished with (though this is done automatically by the
|
|
* testcrypt.py system via Python's reference counting), and may also
|
|
* be mutable. The argument type in C will be a pointer; in Python the
|
|
* corresponding argument will be an instance of a 'Value' object
|
|
* defined in testcrypt.py.
|
|
*
|
|
* 'opt_val_' is a modification of 'val_' to indicate that the pointer
|
|
* may be NULL. In Python this is translated by accepting (or
|
|
* returning) None as an alternative to a Value.
|
|
*
|
|
* 'out_' on an argument type indicates an additional output
|
|
* parameter. The argument type in C has an extra layer of
|
|
* indirection, e.g. an 'out_val_mpint' is an 'mpint **' instead of an
|
|
* 'mpint *', identifying a pointer variable where the returned
|
|
* pointer value will be written. In the Python API, these arguments
|
|
* do not appear in the argument list of the Python function; instead
|
|
* they cause the return value to become a tuple, with additional
|
|
* types appended. For example, a declaration like
|
|
*
|
|
* FUNC(val_foo, example, (ARG(out_val_bar, bar), ARG(val_baz, baz)))
|
|
*
|
|
* would identify a function in C with the following prototype, which
|
|
* returns a 'foo *' directly and a 'bar *' by writing it through the
|
|
* provided 'bar **' pointer argument:
|
|
*
|
|
* foo *example(bar **extra_output, baz *input);
|
|
*
|
|
* and in Python this would become a function taking one argument of
|
|
* type 'baz' and returning a tuple of the form (foo, bar).
|
|
*
|
|
* 'out_' and 'opt_' can go together, if a function returns a second
|
|
* output value but it may in some cases be NULL.
|
|
*
|
|
* 'consumed_' on an argument type indicates that the C function
|
|
* receiving that argument frees it as a side effect.
|
|
*
|
|
* Any argument type which does not start 'val_' is plain old data
|
|
* with no dynamic allocation requirements. Ordinary C integers are
|
|
* sometimes handled this way (e.g. 'uint'). Other plain-data types
|
|
* are represented in Python as a string that must be one of a
|
|
* recognised set of keywords; in C these variously translate into
|
|
* enumeration types (e.g. argon2flavour, rsaorder) or pointers to
|
|
* const vtables of one kind or another (e.g. keyalg, hashalg,
|
|
* primegenpolicy).
|
|
*
|
|
* If a function definition begins with FUNC_WRAPPED rather than FUNC,
|
|
* it means that the underlying C function has a suffix "_wrapper",
|
|
* e.g. ssh_cipher_setiv_wrapper(). Those wrappers are defined in
|
|
* testcrypt.c itself, and change the API or semantics in a way that
|
|
* makes the function more Python-friendly.
|
|
*/
|
|
|
|
/*
|
|
* mpint.h functions.
|
|
*/
|
|
FUNC(val_mpint, mp_new, (ARG(uint, maxbits)))
|
|
FUNC(void, mp_clear, (ARG(val_mpint, x)))
|
|
FUNC(val_mpint, mp_from_bytes_le, (ARG(val_string_ptrlen, bytes)))
|
|
FUNC(val_mpint, mp_from_bytes_be, (ARG(val_string_ptrlen, bytes)))
|
|
FUNC(val_mpint, mp_from_integer, (ARG(uint, n)))
|
|
FUNC(val_mpint, mp_from_decimal_pl, (ARG(val_string_ptrlen, decimal)))
|
|
FUNC(val_mpint, mp_from_decimal, (ARG(val_string_asciz, decimal)))
|
|
FUNC(val_mpint, mp_from_hex_pl, (ARG(val_string_ptrlen, hex)))
|
|
FUNC(val_mpint, mp_from_hex, (ARG(val_string_asciz, hex)))
|
|
FUNC(val_mpint, mp_copy, (ARG(val_mpint, x)))
|
|
FUNC(val_mpint, mp_power_2, (ARG(uint, power)))
|
|
FUNC(uint, mp_get_byte, (ARG(val_mpint, x), ARG(uint, byte)))
|
|
FUNC(uint, mp_get_bit, (ARG(val_mpint, x), ARG(uint, bit)))
|
|
FUNC(void, mp_set_bit, (ARG(val_mpint, x), ARG(uint, bit), ARG(uint, val)))
|
|
FUNC(uint, mp_max_bytes, (ARG(val_mpint, x)))
|
|
FUNC(uint, mp_max_bits, (ARG(val_mpint, x)))
|
|
FUNC(uint, mp_get_nbits, (ARG(val_mpint, x)))
|
|
FUNC(val_string_asciz, mp_get_decimal, (ARG(val_mpint, x)))
|
|
FUNC(val_string_asciz, mp_get_hex, (ARG(val_mpint, x)))
|
|
FUNC(val_string_asciz, mp_get_hex_uppercase, (ARG(val_mpint, x)))
|
|
FUNC(uint, mp_cmp_hs, (ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(uint, mp_cmp_eq, (ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(uint, mp_hs_integer, (ARG(val_mpint, x), ARG(uint, n)))
|
|
FUNC(uint, mp_eq_integer, (ARG(val_mpint, x), ARG(uint, n)))
|
|
FUNC(void, mp_min_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(void, mp_max_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, mp_min, (ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, mp_max, (ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(void, mp_copy_into, (ARG(val_mpint, dest), ARG(val_mpint, src)))
|
|
FUNC(void, mp_select_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, src0), ARG(val_mpint, src1),
|
|
ARG(uint, choose_src1)))
|
|
FUNC(void, mp_add_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(void, mp_sub_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(void, mp_mul_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(val_mpint, mp_add, (ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, mp_sub, (ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, mp_mul, (ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(void, mp_and_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(void, mp_or_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(void, mp_xor_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(void, mp_bic_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(void, mp_copy_integer_into, (ARG(val_mpint, dest), ARG(uint, n)))
|
|
FUNC(void, mp_add_integer_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(uint, n)))
|
|
FUNC(void, mp_sub_integer_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(uint, n)))
|
|
FUNC(void, mp_mul_integer_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(uint, n)))
|
|
FUNC(void, mp_cond_add_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b),
|
|
ARG(uint, yes)))
|
|
FUNC(void, mp_cond_sub_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, a), ARG(val_mpint, b),
|
|
ARG(uint, yes)))
|
|
FUNC(void, mp_cond_swap,
|
|
(ARG(val_mpint, x0), ARG(val_mpint, x1), ARG(uint, swap)))
|
|
FUNC(void, mp_cond_clear, (ARG(val_mpint, x), ARG(uint, clear)))
|
|
FUNC(void, mp_divmod_into,
|
|
(ARG(val_mpint, n), ARG(val_mpint, d), ARG(opt_val_mpint, q),
|
|
ARG(opt_val_mpint, r)))
|
|
FUNC(val_mpint, mp_div, (ARG(val_mpint, n), ARG(val_mpint, d)))
|
|
FUNC(val_mpint, mp_mod, (ARG(val_mpint, x), ARG(val_mpint, modulus)))
|
|
FUNC(val_mpint, mp_nthroot,
|
|
(ARG(val_mpint, y), ARG(uint, n), ARG(opt_val_mpint, remainder)))
|
|
FUNC(void, mp_reduce_mod_2to, (ARG(val_mpint, x), ARG(uint, p)))
|
|
FUNC(val_mpint, mp_invert_mod_2to, (ARG(val_mpint, x), ARG(uint, p)))
|
|
FUNC(val_mpint, mp_invert, (ARG(val_mpint, x), ARG(val_mpint, modulus)))
|
|
FUNC(void, mp_gcd_into,
|
|
(ARG(val_mpint, a), ARG(val_mpint, b), ARG(opt_val_mpint, gcd_out),
|
|
ARG(opt_val_mpint, A_out), ARG(opt_val_mpint, B_out)))
|
|
FUNC(val_mpint, mp_gcd, (ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(uint, mp_coprime, (ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(val_modsqrt, modsqrt_new,
|
|
(ARG(val_mpint, p), ARG(val_mpint, any_nonsquare_mod_p)))
|
|
/* The modsqrt functions' 'success' pointer becomes a second return value */
|
|
FUNC(val_mpint, mp_modsqrt,
|
|
(ARG(val_modsqrt, sc), ARG(val_mpint, x), ARG(out_uint, success)))
|
|
FUNC(val_monty, monty_new, (ARG(val_mpint, modulus)))
|
|
FUNC_WRAPPED(val_mpint, monty_modulus, (ARG(val_monty, mc)))
|
|
FUNC_WRAPPED(val_mpint, monty_identity, (ARG(val_monty, mc)))
|
|
FUNC(void, monty_import_into,
|
|
(ARG(val_monty, mc), ARG(val_mpint, dest), ARG(val_mpint, x)))
|
|
FUNC(val_mpint, monty_import, (ARG(val_monty, mc), ARG(val_mpint, x)))
|
|
FUNC(void, monty_export_into,
|
|
(ARG(val_monty, mc), ARG(val_mpint, dest), ARG(val_mpint, x)))
|
|
FUNC(val_mpint, monty_export, (ARG(val_monty, mc), ARG(val_mpint, x)))
|
|
FUNC(void, monty_mul_into,
|
|
(ARG(val_monty, mc), ARG(val_mpint, dest), ARG(val_mpint, x),
|
|
ARG(val_mpint, y)))
|
|
FUNC(val_mpint, monty_add,
|
|
(ARG(val_monty, mc), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, monty_sub,
|
|
(ARG(val_monty, mc), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, monty_mul,
|
|
(ARG(val_monty, mc), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_mpint, monty_pow,
|
|
(ARG(val_monty, mc), ARG(val_mpint, base), ARG(val_mpint, exponent)))
|
|
FUNC(val_mpint, monty_invert, (ARG(val_monty, mc), ARG(val_mpint, x)))
|
|
FUNC(val_mpint, monty_modsqrt,
|
|
(ARG(val_modsqrt, sc), ARG(val_mpint, mx), ARG(out_uint, success)))
|
|
FUNC(val_mpint, mp_modpow,
|
|
(ARG(val_mpint, base), ARG(val_mpint, exponent), ARG(val_mpint, modulus)))
|
|
FUNC(val_mpint, mp_modmul,
|
|
(ARG(val_mpint, x), ARG(val_mpint, y), ARG(val_mpint, modulus)))
|
|
FUNC(val_mpint, mp_modadd,
|
|
(ARG(val_mpint, x), ARG(val_mpint, y), ARG(val_mpint, modulus)))
|
|
FUNC(val_mpint, mp_modsub,
|
|
(ARG(val_mpint, x), ARG(val_mpint, y), ARG(val_mpint, modulus)))
|
|
FUNC(void, mp_lshift_safe_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, x), ARG(uint, shift)))
|
|
FUNC(void, mp_rshift_safe_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, x), ARG(uint, shift)))
|
|
FUNC(val_mpint, mp_rshift_safe, (ARG(val_mpint, x), ARG(uint, shift)))
|
|
FUNC(void, mp_lshift_fixed_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, x), ARG(uint, shift)))
|
|
FUNC(void, mp_rshift_fixed_into,
|
|
(ARG(val_mpint, dest), ARG(val_mpint, x), ARG(uint, shift)))
|
|
FUNC(val_mpint, mp_rshift_fixed, (ARG(val_mpint, x), ARG(uint, shift)))
|
|
FUNC(val_mpint, mp_random_bits, (ARG(uint, bits)))
|
|
FUNC(val_mpint, mp_random_in_range, (ARG(val_mpint, lo), ARG(val_mpint, hi)))
|
|
|
|
/*
|
|
* ecc.h functions.
|
|
*/
|
|
FUNC(val_wcurve, ecc_weierstrass_curve,
|
|
(ARG(val_mpint, p), ARG(val_mpint, a), ARG(val_mpint, b),
|
|
ARG(opt_val_mpint, nonsquare_mod_p)))
|
|
FUNC(val_wpoint, ecc_weierstrass_point_new_identity, (ARG(val_wcurve, curve)))
|
|
FUNC(val_wpoint, ecc_weierstrass_point_new,
|
|
(ARG(val_wcurve, curve), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_wpoint, ecc_weierstrass_point_new_from_x,
|
|
(ARG(val_wcurve, curve), ARG(val_mpint, x), ARG(uint, desired_y_parity)))
|
|
FUNC(val_wpoint, ecc_weierstrass_point_copy, (ARG(val_wpoint, orig)))
|
|
FUNC(uint, ecc_weierstrass_point_valid, (ARG(val_wpoint, P)))
|
|
FUNC(val_wpoint, ecc_weierstrass_add_general,
|
|
(ARG(val_wpoint, P), ARG(val_wpoint, Q)))
|
|
FUNC(val_wpoint, ecc_weierstrass_add, (ARG(val_wpoint, P), ARG(val_wpoint, Q)))
|
|
FUNC(val_wpoint, ecc_weierstrass_double, (ARG(val_wpoint, P)))
|
|
FUNC(val_wpoint, ecc_weierstrass_multiply,
|
|
(ARG(val_wpoint, B), ARG(val_mpint, n)))
|
|
FUNC(uint, ecc_weierstrass_is_identity, (ARG(val_wpoint, P)))
|
|
/* The output pointers in get_affine all become extra output values */
|
|
FUNC(void, ecc_weierstrass_get_affine,
|
|
(ARG(val_wpoint, P), ARG(out_val_mpint, x), ARG(out_val_mpint, y)))
|
|
FUNC(val_mcurve, ecc_montgomery_curve,
|
|
(ARG(val_mpint, p), ARG(val_mpint, a), ARG(val_mpint, b)))
|
|
FUNC(val_mpoint, ecc_montgomery_point_new,
|
|
(ARG(val_mcurve, curve), ARG(val_mpint, x)))
|
|
FUNC(val_mpoint, ecc_montgomery_point_copy, (ARG(val_mpoint, orig)))
|
|
FUNC(val_mpoint, ecc_montgomery_diff_add,
|
|
(ARG(val_mpoint, P), ARG(val_mpoint, Q), ARG(val_mpoint, PminusQ)))
|
|
FUNC(val_mpoint, ecc_montgomery_double, (ARG(val_mpoint, P)))
|
|
FUNC(val_mpoint, ecc_montgomery_multiply,
|
|
(ARG(val_mpoint, B), ARG(val_mpint, n)))
|
|
FUNC(void, ecc_montgomery_get_affine,
|
|
(ARG(val_mpoint, P), ARG(out_val_mpint, x)))
|
|
FUNC(boolean, ecc_montgomery_is_identity, (ARG(val_mpoint, P)))
|
|
FUNC(val_ecurve, ecc_edwards_curve,
|
|
(ARG(val_mpint, p), ARG(val_mpint, d), ARG(val_mpint, a),
|
|
ARG(opt_val_mpint, nonsquare_mod_p)))
|
|
FUNC(val_epoint, ecc_edwards_point_new,
|
|
(ARG(val_ecurve, curve), ARG(val_mpint, x), ARG(val_mpint, y)))
|
|
FUNC(val_epoint, ecc_edwards_point_new_from_y,
|
|
(ARG(val_ecurve, curve), ARG(val_mpint, y), ARG(uint, desired_x_parity)))
|
|
FUNC(val_epoint, ecc_edwards_point_copy, (ARG(val_epoint, orig)))
|
|
FUNC(val_epoint, ecc_edwards_add, (ARG(val_epoint, P), ARG(val_epoint, Q)))
|
|
FUNC(val_epoint, ecc_edwards_multiply, (ARG(val_epoint, B), ARG(val_mpint, n)))
|
|
FUNC(uint, ecc_edwards_eq, (ARG(val_epoint, P), ARG(val_epoint, Q)))
|
|
FUNC(void, ecc_edwards_get_affine,
|
|
(ARG(val_epoint, P), ARG(out_val_mpint, x), ARG(out_val_mpint, y)))
|
|
|
|
/*
|
|
* The ssh_hash abstraction. Note the 'consumed', indicating that
|
|
* ssh_hash_final puts its input ssh_hash beyond use.
|
|
*
|
|
* ssh_hash_update is an invention of testcrypt, handled in the real C
|
|
* API by the hash object also functioning as a BinarySink.
|
|
*/
|
|
FUNC(opt_val_hash, ssh_hash_new, (ARG(hashalg, alg)))
|
|
FUNC(void, ssh_hash_reset, (ARG(val_hash, h)))
|
|
FUNC(val_hash, ssh_hash_copy, (ARG(val_hash, orig)))
|
|
FUNC_WRAPPED(val_string, ssh_hash_digest, (ARG(val_hash, h)))
|
|
FUNC_WRAPPED(val_string, ssh_hash_final, (ARG(consumed_val_hash, h)))
|
|
FUNC(void, ssh_hash_update, (ARG(val_hash, h), ARG(val_string_ptrlen, data)))
|
|
|
|
FUNC(opt_val_hash, blake2b_new_general, (ARG(uint, hashlen)))
|
|
|
|
/*
|
|
* The ssh2_mac abstraction. Note the optional ssh_cipher parameter
|
|
* to ssh2_mac_new. Also, again, I've invented an ssh2_mac_update so
|
|
* you can put data into the MAC.
|
|
*/
|
|
FUNC(val_mac, ssh2_mac_new, (ARG(macalg, alg), ARG(opt_val_cipher, cipher)))
|
|
FUNC(void, ssh2_mac_setkey, (ARG(val_mac, m), ARG(val_string_ptrlen, key)))
|
|
FUNC(void, ssh2_mac_start, (ARG(val_mac, m)))
|
|
FUNC(void, ssh2_mac_update, (ARG(val_mac, m), ARG(val_string_ptrlen, data)))
|
|
FUNC_WRAPPED(val_string, ssh2_mac_genresult, (ARG(val_mac, m)))
|
|
FUNC(val_string_asciz_const, ssh2_mac_text_name, (ARG(val_mac, m)))
|
|
|
|
/*
|
|
* The ssh_key abstraction. All the uses of BinarySink and
|
|
* BinarySource in parameters are replaced with ordinary strings for
|
|
* the testing API: new_priv_openssh just takes a string input, and
|
|
* all the functions that output key and signature blobs do it by
|
|
* returning a string.
|
|
*/
|
|
FUNC(val_key, ssh_key_new_pub, (ARG(keyalg, alg), ARG(val_string_ptrlen, pub)))
|
|
FUNC(opt_val_key, ssh_key_new_priv,
|
|
(ARG(keyalg, alg), ARG(val_string_ptrlen, pub),
|
|
ARG(val_string_ptrlen, priv)))
|
|
FUNC(opt_val_key, ssh_key_new_priv_openssh,
|
|
(ARG(keyalg, alg), ARG(val_string_binarysource, src)))
|
|
FUNC(opt_val_string_asciz, ssh_key_invalid,
|
|
(ARG(val_key, key), ARG(uint, flags)))
|
|
FUNC(void, ssh_key_sign,
|
|
(ARG(val_key, key), ARG(val_string_ptrlen, data), ARG(uint, flags),
|
|
ARG(out_val_string_binarysink, sig)))
|
|
FUNC(boolean, ssh_key_verify,
|
|
(ARG(val_key, key), ARG(val_string_ptrlen, sig),
|
|
ARG(val_string_ptrlen, data)))
|
|
FUNC(void, ssh_key_public_blob,
|
|
(ARG(val_key, key), ARG(out_val_string_binarysink, blob)))
|
|
FUNC(void, ssh_key_private_blob,
|
|
(ARG(val_key, key), ARG(out_val_string_binarysink, blob)))
|
|
FUNC(void, ssh_key_openssh_blob,
|
|
(ARG(val_key, key), ARG(out_val_string_binarysink, blob)))
|
|
FUNC(val_string_asciz, ssh_key_cache_str, (ARG(val_key, key)))
|
|
FUNC(val_keycomponents, ssh_key_components, (ARG(val_key, key)))
|
|
FUNC(uint, ssh_key_public_bits,
|
|
(ARG(keyalg, self), ARG(val_string_ptrlen, blob)))
|
|
|
|
/*
|
|
* Accessors to retrieve the innards of a 'key_components'.
|
|
*/
|
|
FUNC(uint, key_components_count, (ARG(val_keycomponents, kc)))
|
|
FUNC(opt_val_string_asciz_const, key_components_nth_name,
|
|
(ARG(val_keycomponents, kc), ARG(uint, n)))
|
|
FUNC(opt_val_string_asciz_const, key_components_nth_str,
|
|
(ARG(val_keycomponents, kc), ARG(uint, n)))
|
|
FUNC(opt_val_mpint, key_components_nth_mp,
|
|
(ARG(val_keycomponents, kc), ARG(uint, n)))
|
|
|
|
/*
|
|
* The ssh_cipher abstraction. The in-place encrypt and decrypt
|
|
* functions are wrapped to replace them with versions that take one
|
|
* string and return a separate string.
|
|
*/
|
|
FUNC(opt_val_cipher, ssh_cipher_new, (ARG(cipheralg, alg)))
|
|
FUNC_WRAPPED(void, ssh_cipher_setiv,
|
|
(ARG(val_cipher, c), ARG(val_string_ptrlen, iv)))
|
|
FUNC_WRAPPED(void, ssh_cipher_setkey,
|
|
(ARG(val_cipher, c), ARG(val_string_ptrlen, key)))
|
|
FUNC_WRAPPED(val_string, ssh_cipher_encrypt,
|
|
(ARG(val_cipher, c), ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, ssh_cipher_decrypt,
|
|
(ARG(val_cipher, c), ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, ssh_cipher_encrypt_length,
|
|
(ARG(val_cipher, c), ARG(val_string_ptrlen, blk), ARG(uint, seq)))
|
|
FUNC_WRAPPED(val_string, ssh_cipher_decrypt_length,
|
|
(ARG(val_cipher, c), ARG(val_string_ptrlen, blk), ARG(uint, seq)))
|
|
|
|
/*
|
|
* Integer Diffie-Hellman.
|
|
*/
|
|
FUNC(val_dh, dh_setup_group, (ARG(dh_group, group)))
|
|
FUNC(val_dh, dh_setup_gex, (ARG(val_mpint, p), ARG(val_mpint, g)))
|
|
FUNC(uint, dh_modulus_bit_size, (ARG(val_dh, ctx)))
|
|
FUNC(val_mpint, dh_create_e, (ARG(val_dh, ctx), ARG(uint, nbits)))
|
|
FUNC_WRAPPED(boolean, dh_validate_f, (ARG(val_dh, ctx), ARG(val_mpint, f)))
|
|
FUNC(val_mpint, dh_find_K, (ARG(val_dh, ctx), ARG(val_mpint, f)))
|
|
|
|
/*
|
|
* Elliptic-curve Diffie-Hellman.
|
|
*/
|
|
FUNC(val_ecdh, ssh_ecdhkex_newkey, (ARG(ecdh_alg, alg)))
|
|
FUNC(void, ssh_ecdhkex_getpublic,
|
|
(ARG(val_ecdh, key), ARG(out_val_string_binarysink, pub)))
|
|
FUNC(opt_val_mpint, ssh_ecdhkex_getkey,
|
|
(ARG(val_ecdh, key), ARG(val_string_ptrlen, pub)))
|
|
|
|
/*
|
|
* RSA key exchange, and also the BinarySource get function
|
|
* get_ssh1_rsa_priv_agent, which is a convenient way to make an
|
|
* RSAKey for RSA kex testing purposes.
|
|
*/
|
|
FUNC(val_rsakex, ssh_rsakex_newkey, (ARG(val_string_ptrlen, data)))
|
|
FUNC(uint, ssh_rsakex_klen, (ARG(val_rsakex, key)))
|
|
FUNC(val_string, ssh_rsakex_encrypt,
|
|
(ARG(val_rsakex, key), ARG(hashalg, h), ARG(val_string_ptrlen, plaintext)))
|
|
FUNC(opt_val_mpint, ssh_rsakex_decrypt,
|
|
(ARG(val_rsakex, key), ARG(hashalg, h),
|
|
ARG(val_string_ptrlen, ciphertext)))
|
|
FUNC(val_rsakex, get_rsa_ssh1_priv_agent, (ARG(val_string_binarysource, src)))
|
|
|
|
/*
|
|
* Bare RSA keys as used in SSH-1. The construction API functions
|
|
* write into an existing RSAKey object, so I've invented an 'rsa_new'
|
|
* function to make one in the first place.
|
|
*/
|
|
FUNC(val_rsa, rsa_new, (VOID))
|
|
FUNC(void, get_rsa_ssh1_pub,
|
|
(ARG(val_string_binarysource, src), ARG(val_rsa, key),
|
|
ARG(rsaorder, order)))
|
|
FUNC(void, get_rsa_ssh1_priv,
|
|
(ARG(val_string_binarysource, src), ARG(val_rsa, key)))
|
|
FUNC_WRAPPED(opt_val_string, rsa_ssh1_encrypt,
|
|
(ARG(val_string_ptrlen, data), ARG(val_rsa, key)))
|
|
FUNC(val_mpint, rsa_ssh1_decrypt, (ARG(val_mpint, input), ARG(val_rsa, key)))
|
|
FUNC_WRAPPED(val_string, rsa_ssh1_decrypt_pkcs1,
|
|
(ARG(val_mpint, input), ARG(val_rsa, key)))
|
|
FUNC(val_string_asciz, rsastr_fmt, (ARG(val_rsa, key)))
|
|
FUNC(val_string_asciz, rsa_ssh1_fingerprint, (ARG(val_rsa, key)))
|
|
FUNC(void, rsa_ssh1_public_blob,
|
|
(ARG(out_val_string_binarysink, blob), ARG(val_rsa, key),
|
|
ARG(rsaorder, order)))
|
|
FUNC(int, rsa_ssh1_public_blob_len, (ARG(val_string_ptrlen, data)))
|
|
FUNC(void, rsa_ssh1_private_blob_agent,
|
|
(ARG(out_val_string_binarysink, blob), ARG(val_rsa, key)))
|
|
|
|
/*
|
|
* The PRNG type. Similarly to hashes and MACs, I've invented an extra
|
|
* function prng_seed_update for putting seed data into the PRNG's
|
|
* exposed BinarySink.
|
|
*/
|
|
FUNC(val_prng, prng_new, (ARG(hashalg, hashalg)))
|
|
FUNC(void, prng_seed_begin, (ARG(val_prng, pr)))
|
|
FUNC(void, prng_seed_update, (ARG(val_prng, pr), ARG(val_string_ptrlen, data)))
|
|
FUNC(void, prng_seed_finish, (ARG(val_prng, pr)))
|
|
FUNC_WRAPPED(val_string, prng_read, (ARG(val_prng, pr), ARG(uint, size)))
|
|
FUNC(void, prng_add_entropy,
|
|
(ARG(val_prng, pr), ARG(uint, source_id), ARG(val_string_ptrlen, data)))
|
|
|
|
/*
|
|
* Key load/save functions, or rather, the BinarySource / strbuf API
|
|
* that sits just inside the file I/O versions.
|
|
*/
|
|
FUNC(boolean, ppk_encrypted_s,
|
|
(ARG(val_string_binarysource, src),
|
|
ARG(out_opt_val_string_asciz, comment)))
|
|
FUNC(boolean, rsa1_encrypted_s,
|
|
(ARG(val_string_binarysource, src),
|
|
ARG(out_opt_val_string_asciz, comment)))
|
|
FUNC(boolean, ppk_loadpub_s,
|
|
(ARG(val_string_binarysource, src),
|
|
ARG(out_opt_val_string_asciz, algorithm),
|
|
ARG(out_val_string_binarysink, blob),
|
|
ARG(out_opt_val_string_asciz, comment),
|
|
ARG(out_opt_val_string_asciz_const, error)))
|
|
FUNC(int, rsa1_loadpub_s,
|
|
(ARG(val_string_binarysource, src), ARG(out_val_string_binarysink, blob),
|
|
ARG(out_opt_val_string_asciz, comment),
|
|
ARG(out_opt_val_string_asciz_const, error)))
|
|
FUNC_WRAPPED(opt_val_key, ppk_load_s,
|
|
(ARG(val_string_binarysource, src),
|
|
ARG(out_opt_val_string_asciz, comment),
|
|
ARG(opt_val_string_asciz, passphrase),
|
|
ARG(out_opt_val_string_asciz_const, error)))
|
|
FUNC_WRAPPED(int, rsa1_load_s,
|
|
(ARG(val_string_binarysource, src), ARG(val_rsa, key),
|
|
ARG(out_opt_val_string_asciz, comment),
|
|
ARG(opt_val_string_asciz, passphrase),
|
|
ARG(out_opt_val_string_asciz_const, error)))
|
|
FUNC_WRAPPED(val_string, ppk_save_sb,
|
|
(ARG(val_key, key), ARG(opt_val_string_asciz, comment),
|
|
ARG(opt_val_string_asciz, passphrase), ARG(uint, fmt_version),
|
|
ARG(argon2flavour, flavour), ARG(uint, mem), ARG(uint, passes),
|
|
ARG(uint, parallel)))
|
|
FUNC_WRAPPED(val_string, rsa1_save_sb,
|
|
(ARG(val_rsa, key), ARG(opt_val_string_asciz, comment),
|
|
ARG(opt_val_string_asciz, passphrase)))
|
|
|
|
FUNC(val_string_asciz, ssh2_fingerprint_blob,
|
|
(ARG(val_string_ptrlen, blob), ARG(fptype, fptype)))
|
|
|
|
/*
|
|
* Password hashing.
|
|
*/
|
|
FUNC_WRAPPED(val_string, argon2,
|
|
(ARG(argon2flavour, flavour), ARG(uint, mem), ARG(uint, passes),
|
|
ARG(uint, parallel), ARG(uint, taglen), ARG(val_string_ptrlen, P),
|
|
ARG(val_string_ptrlen, S), ARG(val_string_ptrlen, K),
|
|
ARG(val_string_ptrlen, X)))
|
|
FUNC(val_string, argon2_long_hash,
|
|
(ARG(uint, length), ARG(val_string_ptrlen, data)))
|
|
|
|
/*
|
|
* Key generation functions.
|
|
*/
|
|
FUNC_WRAPPED(val_key, rsa_generate,
|
|
(ARG(uint, bits), ARG(boolean, strong), ARG(val_pgc, pgc)))
|
|
FUNC_WRAPPED(val_key, dsa_generate, (ARG(uint, bits), ARG(val_pgc, pgc)))
|
|
FUNC_WRAPPED(opt_val_key, ecdsa_generate, (ARG(uint, bits)))
|
|
FUNC_WRAPPED(opt_val_key, eddsa_generate, (ARG(uint, bits)))
|
|
FUNC(val_rsa, rsa1_generate,
|
|
(ARG(uint, bits), ARG(boolean, strong), ARG(val_pgc, pgc)))
|
|
FUNC(val_pgc, primegen_new_context, (ARG(primegenpolicy, policy)))
|
|
FUNC_WRAPPED(opt_val_mpint, primegen_generate,
|
|
(ARG(val_pgc, ctx), ARG(consumed_val_pcs, pcs)))
|
|
FUNC(val_string, primegen_mpu_certificate,
|
|
(ARG(val_pgc, ctx), ARG(val_mpint, p)))
|
|
FUNC(val_pcs, pcs_new, (ARG(uint, bits)))
|
|
FUNC(val_pcs, pcs_new_with_firstbits,
|
|
(ARG(uint, bits), ARG(uint, first), ARG(uint, nfirst)))
|
|
FUNC(void, pcs_require_residue,
|
|
(ARG(val_pcs, s), ARG(val_mpint, mod), ARG(val_mpint, res)))
|
|
FUNC(void, pcs_require_residue_1, (ARG(val_pcs, s), ARG(val_mpint, mod)))
|
|
FUNC(void, pcs_require_residue_1_mod_prime,
|
|
(ARG(val_pcs, s), ARG(val_mpint, mod)))
|
|
FUNC(void, pcs_avoid_residue_small,
|
|
(ARG(val_pcs, s), ARG(uint, mod), ARG(uint, res)))
|
|
FUNC(void, pcs_try_sophie_germain, (ARG(val_pcs, s)))
|
|
FUNC(void, pcs_set_oneshot, (ARG(val_pcs, s)))
|
|
FUNC(void, pcs_ready, (ARG(val_pcs, s)))
|
|
FUNC(void, pcs_inspect,
|
|
(ARG(val_pcs, pcs), ARG(out_val_mpint, limit_out),
|
|
ARG(out_val_mpint, factor_out), ARG(out_val_mpint, addend_out)))
|
|
FUNC(val_mpint, pcs_generate, (ARG(val_pcs, s)))
|
|
FUNC(val_pockle, pockle_new, (VOID))
|
|
FUNC(uint, pockle_mark, (ARG(val_pockle, pockle)))
|
|
FUNC(void, pockle_release, (ARG(val_pockle, pockle), ARG(uint, mark)))
|
|
FUNC(pocklestatus, pockle_add_small_prime,
|
|
(ARG(val_pockle, pockle), ARG(val_mpint, p)))
|
|
FUNC_WRAPPED(pocklestatus, pockle_add_prime,
|
|
(ARG(val_pockle, pockle), ARG(val_mpint, p),
|
|
ARG(mpint_list, factors), ARG(val_mpint, witness)))
|
|
FUNC(val_string, pockle_mpu, (ARG(val_pockle, pockle), ARG(val_mpint, p)))
|
|
FUNC(val_millerrabin, miller_rabin_new, (ARG(val_mpint, p)))
|
|
FUNC(mr_result, miller_rabin_test,
|
|
(ARG(val_millerrabin, mr), ARG(val_mpint, w)))
|
|
|
|
/*
|
|
* Miscellaneous.
|
|
*/
|
|
FUNC(val_wpoint, ecdsa_public, (ARG(val_mpint, private_key), ARG(keyalg, alg)))
|
|
FUNC(val_epoint, eddsa_public, (ARG(val_mpint, private_key), ARG(keyalg, alg)))
|
|
FUNC_WRAPPED(val_string, des_encrypt_xdmauth,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, des_decrypt_xdmauth,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, des3_encrypt_pubkey,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, des3_decrypt_pubkey,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, des3_encrypt_pubkey_ossh,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, iv),
|
|
ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, des3_decrypt_pubkey_ossh,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, iv),
|
|
ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, aes256_encrypt_pubkey,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, iv),
|
|
ARG(val_string_ptrlen, blk)))
|
|
FUNC_WRAPPED(val_string, aes256_decrypt_pubkey,
|
|
(ARG(val_string_ptrlen, key), ARG(val_string_ptrlen, iv),
|
|
ARG(val_string_ptrlen, blk)))
|
|
FUNC(uint, crc32_rfc1662, (ARG(val_string_ptrlen, data)))
|
|
FUNC(uint, crc32_ssh1, (ARG(val_string_ptrlen, data)))
|
|
FUNC(uint, crc32_update, (ARG(uint, crc_input), ARG(val_string_ptrlen, data)))
|
|
FUNC(boolean, crcda_detect,
|
|
(ARG(val_string_ptrlen, packet), ARG(val_string_ptrlen, iv)))
|
|
FUNC(val_string, get_implementations_commasep, (ARG(val_string_ptrlen, alg)))
|
|
FUNC(void, http_digest_response,
|
|
(ARG(out_val_string_binarysink, response),
|
|
ARG(val_string_ptrlen, username), ARG(val_string_ptrlen, password),
|
|
ARG(val_string_ptrlen, realm), ARG(val_string_ptrlen, method),
|
|
ARG(val_string_ptrlen, uri), ARG(val_string_ptrlen, qop),
|
|
ARG(val_string_ptrlen, nonce), ARG(val_string_ptrlen, opaque),
|
|
ARG(uint, nonce_count), ARG(httpdigesthash, hash),
|
|
ARG(boolean, hash_username)))
|
|
|
|
/*
|
|
* These functions aren't part of PuTTY's own API, but are additions
|
|
* by testcrypt itself for administrative purposes.
|
|
*/
|
|
FUNC(void, random_queue, (ARG(val_string_ptrlen, data)))
|
|
FUNC(uint, random_queue_len, (VOID))
|
|
FUNC(void, random_make_prng,
|
|
(ARG(hashalg, hashalg), ARG(val_string_ptrlen, seed)))
|
|
FUNC(void, random_clear, (VOID))
|