Dh Lua Reference Documentation
chilkat.Dh
Current Version: 11.7.0
Markdown version of this page for AI tools (v 11.7.0) · all AI docs
Chilkat.Dh
Use
Use
Use
Use
Use
The shared secret is typically used as input to a key derivation step
before being used for encryption or authentication.
For an extended overview, see
Dh Class Overview.
Perform Diffie-Hellman shared-secret key exchange.
Chilkat.Dh provides the core operations needed for
Diffie-Hellman shared-secret exchange. It allows two parties to agree on a
shared secret over an insecure channel by using common Diffie-Hellman
parameters, generating public exchange values, and computing the same shared
secret from the other party's public value.
Choose known parameters
UseKnownPrime when the application wants to use a
predefined Diffie-Hellman prime group.
Generate parameters
GenPG to generate Diffie-Hellman parameters when custom
prime and generator values are required.
Set custom P and G
SetPG when the prime and generator are already known or
have been received from another party or protocol.
Create the exchange value
CreateE to create the public Diffie-Hellman value that
is sent to the other party.
Compute the shared secret
FindK with the other party's public exchange value to
compute the shared secret.
Use the result carefully
CreateE, exchange public values with the
other party, then call FindK to compute the shared secret. The
primary methods are UseKnownPrime, GenPG,
SetPG, CreateE, and FindK.
Object Creation
local chilkat = require("chilkat")
local dh = chilkat.Dh.new()Creates the object (chilkat.Dh() does the same). Lua's garbage collector frees it when it is no longer referenced; dh:dispose() frees it at once, and in Lua 5.4 and later local dh <close> = chilkat.Dh.new() frees it when the block ends. Calling a method of a disposed object raises an error.
Errors
A method that fails returns nil followed by the error text, as io.open does: local body, err = dh:method(...), where err is the object's last_error_text. Wrap the call in assert() to raise an error with that text instead. Methods that answer a question return true or false, numbers are returned as they are (check last_method_success where the description says a value means failure), and property reads and writes never fail for Chilkat reasons.
Misuse raises a Lua error: a wrong argument type or a missing argument (bad argument #1 to ...), an unknown property name, a write to a read-only property, an out-of-range integer, or an object of the wrong class.
Names are Chilkat's in snake_case: QuickGetStr is quick_get_str, LastErrorText is last_error_text. Properties are fields (dh.verbose_logging = true) and methods use the colon (dh:method(...)). Strings are UTF-8; binary data is a Lua string of bytes. Indexes are 0-based, as in every Chilkat API. Unlocking: call chilkat.unlock_bundle("...") once at startup.
Properties
DebugLogFilePath
local strVal = dh.debug_log_file_path
dh.debug_log_file_path = strVal
If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.
Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.
Possible causes of hangs include:
- A timeout property set to 0, indicating an infinite timeout.
- A hang occurring within an event callback in the application code.
- An internal bug in the Chilkat code causing the hang.
G
local intVal = dh.g
Returns the current Diffie-Hellman generator, g. The generator is the
small public integer used with the prime modulus p in the modular
exponentiation operations that create the public exchange value and shared secret.
For this class, g is expected to be 2 or 5.
Its value is established by UseKnownPrime, GenPG, or
SetPG.
p and g values for the exchange.
LastErrorHtml
local strVal = dh.last_error_html
Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastErrorText
local strVal = dh.last_error_text
Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
LastErrorXml
local strVal = dh.last_error_xml
Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.
topLastMethodSuccess
local boolVal = dh.last_method_success
dh.last_method_success = boolVal
Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.
P
local strVal = dh.p
Returns the current Diffie-Hellman prime modulus, p, as a
hex-encoded SSH1-format bignum. The value is established by
UseKnownPrime, GenPG, or SetPG.
The modulus is a safe prime: p = 2q + 1, where
q is also prime. Safe-prime groups are commonly used for
finite-field Diffie-Hellman because their subgroup structure is well understood.
p.
p and g.
VerboseLogging
local boolVal = dh.verbose_logging
dh.verbose_logging = boolVal
If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.
Version
local strVal = dh.version
Methods
CreateE
-- str is a string, or nil and err on failure
local str, err = dh:create_e(num_bits)
Creates this party's public Diffie-Hellman exchange value, conventionally written
as E = gx mod p. Before calling this method, initialize
the common Diffie-Hellman parameters by calling UseKnownPrime,
GenPG, or SetPG.
(num_bitsnumBits) controls the size of the randomly
generated private exponent retained internally by this Dh object.
Chilkat recommends setting it to twice the desired strength of the symmetric key
that will ultimately be derived. For example, use 256 when the
protocol will derive a 128-bit key.
The returned E value is a hex-encoded SSH1-format bignum. It is
public and is sent to the other party. The size of the eventual shared-secret
integer is determined primarily by p; numBits does
not make the returned shared secret a fixed-length symmetric key.
FindK on this same Dh object after receiving the
other party's exchange value. CreateE stores the corresponding
private value internally, and FindK needs it to compute the shared
secret. Use a separate Dh object for each party and generate a
fresh exchange value for each session.
For language bindings where a string return cannot directly communicate failure,
check LastMethodSuccess. If it is FALSE, inspect
LastErrorText.
Returns the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.
FindK
-- str is a string, or nil and err on failure
local str, err = dh:find_k(e)
Computes the Diffie-Hellman shared secret from the other party's public exchange
value. is the peer's eE value, encoded as the
hexadecimal representation of an SSH1-format bignum.
This method must be called on the same Dh object that previously
called CreateE. Both parties must also be using the same
p and g parameters. Internally, the method computes
K = Ex mod p, where x is the private value
generated by CreateE.
The result is the shared-secret integer K, returned as a
hex-encoded SSH1-format bignum. When the exchange is performed correctly, both
parties compute the same value.
For language bindings where a string return cannot directly communicate failure,
check LastMethodSuccess. If it is FALSE, inspect
LastErrorText.
Returns the string, or nil, err on failure (or when nothing is found). The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.
GenPG
-- g is an integer
-- ok is true, or nil and err on failure
local ok, err = dh:gen_pg(num_bits, g)
Generates new finite-field Diffie-Hellman parameters and stores them in this
object. specifies the size of the safe prime num_bitsp in
bits, and specifies the generator gg, which should
be 2 or 5.
On success, the generated values are available through the P and
G properties. The prime generation and validation process is
computationally expensive, especially for large groups.
UseKnownPrime or parameters mandated
by the surrounding protocol instead of generating a new group. Standardized
groups improve interoperability and avoid the cost and risk of custom parameter
generation.
Returns TRUE if the parameters were generated successfully;
otherwise returns FALSE. Check LastErrorText for
failure details.
Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.
SetPG
-- g is an integer
-- ok is true, or nil and err on failure
local ok, err = dh:set_pg(p, g)
Sets explicit finite-field Diffie-Hellman parameters for this object.
is the prime modulus pp, supplied as a
hex-encoded SSH1-format bignum, and is the generator
gg, normally 2 or 5.
The method validates that the supplied values satisfy the requirements expected
by this Diffie-Hellman implementation. It returns TRUE if the
parameters are accepted; otherwise it returns FALSE.
p is not ordinary integer hex. It must contain the hexadecimal
encoding of the SSH1 bignum representation, including its bit-length prefix.
The P property of another Chilkat Dh object is
already in the required form.
p and g.
These values are public, but untrusted or nonstandard parameters should not be
accepted unless the protocol explicitly permits them and their origin is
authenticated.
Returns true on success, nil, err on failure. The second return value, err, is the object's last_error_text; wrap the call in assert() to raise an error instead.
UseKnownPrime
dh:use_known_prime(index)
Selects one of eight built-in safe-prime MODP groups and sets the object's
P and G properties. is a Chilkat
selector from index1 through 8; it is not
the IKE group number.
index |
MODP group | Prime bits | Definition | G |
|---|---|---|---|---|
1 | Group 1 | 768 | RFC 2409, section 6.1 | 2 |
2 | Group 2 | 1024 | RFC 2409, section 6.2 | 2 |
3 | Group 5 | 1536 | RFC 3526, section 2 | 2 |
4 | Group 14 | 2048 | RFC 3526, section 3 | 2 |
5 | Group 15 | 3072 | RFC 3526, section 4 | 2 |
6 | Group 16 | 4096 | RFC 3526, section 5 | 2 |
7 | Group 17 | 6144 | RFC 3526, section 6 | 2 |
8 | Group 18 | 8192 | RFC 3526, section 7 | 2 |
1, 2, and 3 are legacy groups
and should not be chosen for new systems. Selector 4 is the
2048-bit group 14; selector 5 is the 3072-bit group 15 and is
commonly used when approximately 128-bit classical security is required.
Always use the group required by the protocol or the communicating peer.