Chilkat Examples

ChilkatHOMEAndroid™Classic ASPCC++C#Mono C#.NET Core C#C# UWP/WinRTDataFlexDelphi ActiveXDelphi DLLVisual FoxProJavaLianjaMFCObjective-CPerlPHP ActiveXPHP ExtensionPowerBuilderPowerShellPureBasicCkPythonChilkat2-PythonRubySQL ServerSwift 2Swift 3,4,5...TclUnicode CUnicode C++Visual Basic 6.0VB.NETVB.NET UWP/WinRTVBScriptXojo PluginNode.jsExcelGo

C# UWP/WinRT Examples

Web API Categories

ASN.1
Amazon EC2
Amazon Glacier
Amazon S3
Amazon S3 (new)
Amazon SES
Amazon SNS
Amazon SQS
Azure Cloud Storage
Azure Service Bus
Azure Table Service
Base64
Bounced Email
Box
CAdES
CSR
CSV
Certificates
Compression
DKIM / DomainKey
DSA
Diffie-Hellman
Digital Signatures
Dropbox
Dynamics CRM
EBICS
ECC
Ed25519
Email Object
Encryption
FTP
FileAccess
Firebase
GMail REST API
GMail SMTP/IMAP/POP
Geolocation
Google APIs
Google Calendar
Google Cloud SQL
Google Cloud Storage
Google Drive
Google Photos
Google Sheets
Google Tasks
Gzip
HTML-to-XML/Text
HTTP

HTTP Misc
IMAP
JSON
JSON Web Encryption (JWE)
JSON Web Signatures (JWS)
JSON Web Token (JWT)
Java KeyStore (JKS)
MHT / HTML Email
MIME
MS Storage Providers
Microsoft Graph
NTLM
OAuth1
OAuth2
OIDC
Office365
OneDrive
OpenSSL
Outlook
Outlook Calendar
Outlook Contact
PDF Signatures
PEM
PFX/P12
PKCS11
POP3
PRNG
REST
REST Misc
RSA
SCP
SCard
SFTP
SMTP
SSH
SSH Key
SSH Tunnel
ScMinidriver
SharePoint
Socket/SSL/TLS
Spider
Stream
Tar Archive
Upload
WebSocket
XAdES
XML
XML Digital Signatures
XMP
Zip
curl

 

 

 

(C# UWP/WinRT) Diffie-Hellman Key Exchange (DH)

Diffie-Hellman key exchange (DH) is a cryptographic protocol that allows two parties that have no prior knowledge of each other to jointly establish a shared secret key.

This example demonstrates how two parties (Alice and Bob) can compute an N-bit shared secret key without the key ever being transmitted.

Chilkat Universal Windows Platform (UWP) / WinRT Downloads

Chilkat for the Universal Windows Platform (UWP)

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

// Create two separate instances of the DH object.
Chilkat.Dh dhBob = new Chilkat.Dh();
Chilkat.Dh dhAlice = new Chilkat.Dh();

// The DH algorithm begins with a large prime, P, and a generator, G.  
// These don't have to be secret, and they may be transmitted over an insecure channel.  
// The generator is a small integer and typically has the value 2 or 5.

// The Chilkat DH component provides the ability to use known
// "safe" primes, as well as a method to generate new safe primes.

// This example will use a known safe prime.  Generating
// new safe primes is a time-consuming CPU intensive task
// and is normally done offline.

// Bob will choose to use the 2nd of our 8 pre-chosen safe primes.  
// It is the Prime for the 2nd Oakley Group (RFC 2409) -- 
// 1024-bit MODP Group.  Generator is 2. 
// The prime is: 2^1024 - 2^960 - 1 + 2^64 * { [2^894 pi] + 129093 }
dhBob.UseKnownPrime(2);

// The computed shared secret will be equal to the size of the prime (in bits).
// In this case the prime is 1024 bits, so the shared secret will be 128 bytes (128 * 8 = 1024).
// However, the result is returned as an SSH1-encoded bignum in hex string format.
// The SSH1-encoding prepends a 2-byte count, so the result is going  to be 2 bytes
// longer: 130 bytes.  This results in a hex string that is 260 characters long (two chars
// per byte for the hex encoding).

string p;
int g;
// Bob will now send P and G to Alice.
p = dhBob.P;
g = dhBob.G;

// Alice calls SetPG to set P and G.  SetPG checks
// the values to make sure it's a safe prime and will
// return false if not.
bool success = dhAlice.SetPG(p,g);
if (success != true) {
    Debug.WriteLine("P is not a safe prime");
    return;
}

// Each side begins by generating an "E"
// value.  The CreateE method has one argument: numBits.
// It should be set to twice the size of the number of bits
// in the session key.

// Let's say we want to generate a 128-bit session key
// for AES encryption.  The shared secret generated by the Diffie-Hellman
// algorithm will be longer, so we'll hash the result to arrive at the
// desired session key length.  However, the length of the session
// key we'll utlimately produce determines the value that should be
// passed to the CreateE method.

// In this case, we'll be creating a 128-bit session key, so pass 256 to CreateE.
// This setting is for security purposes only -- the value
// passed to CreateE does not change the length of the shared secret
// that is produced by Diffie-Hellman.  
// Also, there is no need to pass in a value larger
// than 2 times the expected session key length.  It suffices to
// pass exactly 2 times the session key length.

// Bob generates a random E (which has the mathematical
// properties required for DH).
string eBob;
eBob = dhBob.CreateE(256);

// Alice does the same:
string eAlice;
eAlice = dhAlice.CreateE(256);

// The "E" values are sent over the insecure channel.
// Bob sends his "E" to Alice, and Alice sends her "E" to Bob.

// Each side computes the shared secret by calling FindK.
// "K" is the shared-secret.

string kBob;
string kAlice;

// Bob computes the shared secret from Alice's "E":
kBob = dhBob.FindK(eAlice);

// Alice computes the shared secret from Bob's "E":
kAlice = dhAlice.FindK(eBob);

// Amazingly, kBob and kAlice are identical and the expected
// length (260 characters).  The strings contain the hex encoded bytes of
// our shared secret:
Debug.WriteLine("Bob's shared secret:");
Debug.WriteLine(kBob);
Debug.WriteLine("Alice's shared secret (should be equal to Bob's)");
Debug.WriteLine(kAlice);

// To arrive at a 128-bit session key for AES encryption, Bob and Alice should
// both transform the raw shared secret using a hash algorithm that produces
// the size of session key desired.   MD5 produces a 16-byte (128-bit) result, so
// this is a good choice for 128-bit AES.

// To produce the session key:
Chilkat.Crypt2 crypt = new Chilkat.Crypt2();

crypt.EncodingMode = "hex";
crypt.HashAlgorithm = "md5";

string sessionKey;
sessionKey = crypt.HashStringENC(kBob);

Debug.WriteLine("128-bit Session Key:");
Debug.WriteLine(sessionKey);

// Encrypt something...
crypt.CryptAlgorithm = "aes";
crypt.KeyLength = 128;
crypt.CipherMode = "cbc";

// Use an IV that is the MD5 hash of the session key...
string iv;
iv = crypt.HashStringENC(sessionKey);

// AES uses a 16-byte IV:
Debug.WriteLine("Initialization Vector:");
Debug.WriteLine(iv);

crypt.SetEncodedKey(sessionKey,"hex");
crypt.SetEncodedIV(iv,"hex");

// Encrypt some text:
string cipherText64;

crypt.EncodingMode = "base64";
cipherText64 = crypt.EncryptStringENC("The quick brown fox jumps over the lazy dog");
Debug.WriteLine(cipherText64);

string plainText;
plainText = crypt.DecryptStringENC(cipherText64);

Debug.WriteLine(plainText);

 

© 2000-2022 Chilkat Software, Inc. All Rights Reserved.