static void Main(string[] args)
{
Chilkat.Global glob = new Chilkat.Global();
bool success = glob.UnlockBundle("Anything for 30-day trial");
if (success != true)
{
Debug.WriteLine(glob.LastErrorText);
return;
}
int status = glob.UnlockStatus;
if (status == 2)
{
Debug.WriteLine("Unlocked using purchased unlock code.");
}
else
{
Debug.WriteLine("Unlocked in trial mode.");
}
// The LastErrorText can be examined in the success case to see if it was unlocked in
// trial more, or with a purchased unlock code.
Debug.WriteLine(glob.LastErrorText);
var certPath = $@"{AppDomain.CurrentDomain.BaseDirectory}server_20110101.pfx";
var server = "83.220.246.39";
var port = 9000;
var maxWaitMillisec = 10000;
//var certPass = "******";
using (var socket = new Chilkat.Socket
{
SocksHostname = server,
SocksPort = port,
SocksUsername = "******",
SocksPassword = "******",
SocksVersion = 5,
MaxReadIdleMs = maxWaitMillisec,
MaxSendIdleMs = maxWaitMillisec
})
{
var cert = new Chilkat.Cert();
cert.LoadFromFile(certPath);
socket.SetSslClientCert(cert);
socket.Connect(server, port, true, maxWaitMillisec);
var receivedString = socket.ReceiveString();
Console.WriteLine(receivedString ?? "none");
}
}
// This event fires in a background thread, so be careful about touching UI buttons, textboxes, etc.
void listenSocket_OnTaskCompleted(object sender, Chilkat.TaskCompletedEventArgs args)
{
if (args.Task.LastMethodSuccess)
{
// We'll be acting as an HTTP server.
// We'll read the incoming HTTP request and send a response.
Chilkat.Socket httpServerSock = new Chilkat.Socket();
// Let's inject this Chilkat.Socket object with the results of the task.
httpServerSock.LoadTaskResult(args.Task);
// Read the incoming start line..
string startLine = httpServerSock.ReceiveUntilMatch("\r\n");
// Read the HTTP request. We'll read to the first double CRLF, which is to the end of the
// request header. This should be all that is coming because the request should be a GET request (i.e. no request body).
string requestHeader = httpServerSock.ReceiveUntilMatch("\r\n\r\n");
// The HTTP request's startLine contains the information we need..
// It looks like this:
// GET /?state=ARudjbBgI8FxgNGqEdUsv1TfYL4rAkOdDObQUT-dV8g&code=4/ovg2Tct4_Ct-BUSPnBRKyXJqsO4nGj9FNxqexxD0KK8&authuser=0&session_state=93ef25f6921934eed290ca484acb58653585ee71..bed8&prompt=consent HTTP/1.1
// Parse the startLine by getting rid of the "GET" and "HTTP/1.1", and making it a URL that we can load into a Chilkat.HttpRequest object.
string tempUrl = "http://www.anything.com" + startLine.Replace("GET ", "").Replace(" HTTP/1.1", "").Trim();
Chilkat.HttpRequest tempReq = new Chilkat.HttpRequest();
tempReq.SetFromUrl(tempUrl);
string state = tempReq.GetParam("state");
string code = tempReq.GetParam("code");
string session_state = tempReq.GetParam("session_state");
// Now send a response..
string responseString = string.Format("<html><body><ul><li>state: " + state + "<li>code: " + code + "<li>session_state: " + session_state + "</ul></body></html>");
httpServerSock.SendString(responseString);
httpServerSock.Close(10);
fgAppendToErrorLog(startLine + requestHeader + "\r\n----\r\n");
// Now exchange the code for an access token and a refresh token.
// (The args.Task.UserData contains the JSON we initially stashed in the Task's UserData property.)
googleExchangeCodeForToken(code, args.Task.UserData);
}
else
{
// Failed...
fgAppendToErrorLog(args.Task.ResultErrorText);
}
}
/// <summary>
/// https://www.example-code.com/dotnet-core/dnsLookup.asp
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public async Task <NetworkDnsQueryLookup> DnsChilkatLookup(string target)
{
Chilkat.Socket socket = new Chilkat.Socket();
socket.UnlockComponent("unlock_code");
int milliseconds = 10000;
var address = await Task.Run(() => { return(socket.DnsLookup(target, milliseconds)); });
var networkDnsQueryLookup = new NetworkDnsQueryLookup
{
IpAddress = address,
};
Debug.Assert(!string.IsNullOrEmpty(networkDnsQueryLookup.IpAddress), "IP Address empty? Why?");
if (!socket.LastMethodSuccess)
{
Debug.WriteLine(socket.LastErrorText);
return(default);
// URLs to help understand this topic:
// https://developers.google.com/identity/protocols/OAuth2InstalledApp
//
private bool oauth2_google(string scope)
{
// Generates state and PKCE values.
string state = m_prng.GenRandom(32, base64Url);
string code_verifier = m_prng.GenRandom(32, base64Url);
Chilkat.Crypt2 crypt = new Chilkat.Crypt2();
crypt.EncodingMode = base64Url;
crypt.HashAlgorithm = "SHA256";
string code_challenge = crypt.HashStringENC(code_verifier);
const string code_challenge_method = "S256";
//Create a Chilkat socket for listening. Begin listening asynchronously.
Chilkat.Socket listenSocket = new Chilkat.Socket();
int backlog = 5;
int listenPort = 0;
// Passing a listenPort = 0 causes BindAndListen to find a random unused port.
// The chosen port will be available via the ListenPort property.
if (!listenSocket.BindAndListen(listenPort, backlog))
{
fgAppendToErrorLog(listenSocket.LastErrorText);
popupError("Failed to BindAndListen");
return(false);
}
// Get the chosen listen port
// This ListenPort property is available starting in Chilkat v9.5.0.59
listenPort = listenSocket.ListenPort;
// Creates a redirect URI using an available port on the loopback address.
string redirect_uri = "http://127.0.0.1:" + listenPort.ToString() + "/";
//Wait a max of 5 minutes. The OnTaskCompleted event is called when an incoming connection
//arrives, or when the listen failed.
listenSocket.OnTaskCompleted += listenSocket_OnTaskCompleted;
Chilkat.Task task = listenSocket.AcceptNextConnectionAsync(5 * 60000);
if (task == null)
{
MessageBox.Show("Failed to start socket accept...");
return(false);
}
// Add some information that will be needed by the TaskCompleted event..
Chilkat.JsonObject taskData = new Chilkat.JsonObject();
taskData.AppendString("code_verifier", code_verifier);
taskData.AppendString("redirect_uri", redirect_uri);
task.UserData = taskData.Emit();
// Start the task.
task.Run();
// Creates the OAuth 2.0 authorization request.
Chilkat.StringBuilder sbAuthRequest = new Chilkat.StringBuilder();
sbAuthRequest.Append(authorizationEndpoint);
sbAuthRequest.Append("?response_type=code&scope=");
sbAuthRequest.Append(m_encoder.EncodeString(scope, "utf-8", "url"));
sbAuthRequest.Append("&redirect_uri=");
sbAuthRequest.Append(m_encoder.EncodeString(redirect_uri, "utf-8", "url"));
sbAuthRequest.Append("&client_id=");
sbAuthRequest.Append(googleAppClientId);
sbAuthRequest.Append("&state=");
sbAuthRequest.Append(state);
sbAuthRequest.Append("&code_challenge=");
sbAuthRequest.Append(code_challenge);
sbAuthRequest.Append("&code_challenge_method=");
sbAuthRequest.Append(code_challenge_method);
// Here is a shorter way of building the URL in C#
//string authorizationRequest = string.Format("{0}?response_type=code&scope={6}&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}",
// authorizationEndpoint, // 0
// System.Uri.EscapeDataString(redirect_uri), // 1
// googleAppClientId, // 2
// state, // 3
// code_challenge, // 4
// code_challenge_method, // 5
// System.Uri.EscapeDataString(scope)); // 6
// Get authorization from Google account owner...
webBrowser1.Navigate(sbAuthRequest.GetAsString());
return(true);
}
public static void tunnel(int serverPort)
{
Chilkat.Socket tunnel = new Chilkat.Socket();
bool success;
// Anything unlocks the component and begins a fully-functional 30-day trial.
success = tunnel.UnlockComponent("Anything for 30-day trial");
if (success != true)
{
Console.WriteLine(tunnel.LastErrorText);
return;
}
string sshHostname = "172.24.19.18";
int sshPort = 22;
// Connect to an SSH server and establish the SSH tunnel:
success = tunnel.SshOpenTunnel(sshHostname, sshPort);
if (success != true)
{
Console.WriteLine(tunnel.LastErrorText);
return;
}
// Authenticate with the SSH server via a login/password
// or with a public key.
// This example demonstrates SSH password authentication.
success = tunnel.SshAuthenticatePw("rishabh", "root123");
if (success != true)
{
Console.WriteLine(tunnel.LastErrorText);
return;
}
// OK, the SSH tunnel is setup. Now open a channel within the tunnel.
// Once the channel is obtained, the Socket API may
// be used exactly the same as usual, except all communications
// are sent through the channel in the SSH tunnel.
// Any number of channels may be created from the same SSH tunnel.
// Multiple channels may coexist at the same time.
// Connect to an NIST time server and read the current date/time
Chilkat.Socket channel = null;
int maxWaitMs = 4000;
bool useTls = false;
channel = tunnel.SshOpenChannel("time-c-g.nist.gov", 37, useTls, maxWaitMs);
if (channel == null)
{
Console.WriteLine(tunnel.LastErrorText);
return;
}
// The time server will send a big-endian 32-bit integer representing
// the number of seconds since since 00:00 (midnight) 1 January 1900 GMT.
// The ReceiveInt32 method will receive a 4-byte integer, but returns
// true or false to indicate success. If successful, the integer
// is obtained via the ReceivedInt property.
bool bigEndian = true;
success = channel.ReceiveInt32(bigEndian);
if (success != true)
{
Console.WriteLine(channel.LastErrorText);
return;
}
Chilkat.CkDateTime dt = new Chilkat.CkDateTime();
dt.SetFromNtpTime(channel.ReceivedInt);
// Show the current local date/time
bool bLocalTime = true;
Console.WriteLine("Current local date/time: " + dt.GetAsRfc822(bLocalTime));
bool isSent = channel.SendString("echo hello world");
if (isSent != true)
{
Console.WriteLine(channel.LastErrorText);
return;
}
Console.WriteLine("---- echo hello world ----");
// Close the SSH channel.
success = channel.Close(maxWaitMs);
if (success != true)
{
Console.WriteLine(channel.LastErrorText);
return;
}
// It is possible to create a new channel from the existing SSH tunnel for the next connection:
// Any number of channels may be created from the same SSH tunnel.
// Multiple channels may coexist at the same time.
channel = tunnel.SshOpenChannel("time-a.nist.gov", 37, useTls, maxWaitMs);
if (channel == null)
{
Console.WriteLine(tunnel.LastErrorText);
return;
}
// Review the LastErrorText to see that the connection was made via the SSH tunnel:
Console.WriteLine(tunnel.LastErrorText);
// Close the connection to time-a.nist.gov. This is actually closing our channel
// within the SSH tunnel, but keeps the tunnel open for the next port-forwarded connection.
success = channel.Close(maxWaitMs);
if (success != true)
{
Console.WriteLine(channel.LastErrorText);
return;
}
// Finally, close the SSH tunnel.
success = tunnel.SshCloseTunnel();
if (success != true)
{
Console.WriteLine(tunnel.LastErrorText);
return;
}
Console.WriteLine("TCP SSH tunneling example completed.");
}
static void Main(string[] args)
{
int responseBytesTotal = 0;
int sequence = 0, i = 0;
Socket listenSocket = InitializeSocketLibrary();
Socket outboundSocket = InitializeSocketLibrary();
File.Delete(PacketRealTimeLog);
// Bind on port 443
if (listenSocket.BindAndListen(443, 25) != true)
{
Console.WriteLine(listenSocket.LastErrorText + "\r\n");
return;
}
Console.WriteLine("[BREACH SSL Relay ready on 443]\n");
// Keep the proxy up & running
while (true)
{
// Every 1000 closed sockets, force cleanup & garbage collection
if (++i % 1000 == 0)
{
Console.Write("## RESET CLEANUP...");
Thread.Sleep(500);
listenSocket.Close(10000);
outboundSocket.Close(10000);
listenSocket = InitializeSocketLibrary();
outboundSocket = InitializeSocketLibrary();
if (!listenSocket.BindAndListen(443, 25))
{
Console.WriteLine(listenSocket.LastErrorText + "\r\n");
return;
}
GC.WaitForFullGCComplete();
Console.WriteLine(" Done!");
}
Chilkat.Socket connectedSocket = null;
// Listen to incoming client
do
{
try
{
connectedSocket = listenSocket.AcceptNextConnection(6000000);
}
catch (System.AccessViolationException e)
{
connectedSocket = null;
Console.WriteLine("## Error (001): " + e);
Thread.Sleep(500);
}
} while (connectedSocket == null);
// Connect to outbound target
// BLIND SSL Relay (no need to establish a new SSL tunnel)
if (!outboundSocket.Connect(TargetIP, 443, false, 10000))
{
Console.WriteLine(outboundSocket.LastErrorText + "\r\n");
continue;
}
// Set maximum timeouts for reading an writing (in millisec)
connectedSocket.MaxReadIdleMs = 90000;
connectedSocket.MaxSendIdleMs = 90000;
outboundSocket.MaxReadIdleMs = 90000;
outboundSocket.MaxSendIdleMs = 90000;
int received = 0;
bool receivingClient = false;
bool receivingServer = false;
// Main loop for SSL Proxy - Processing and forwarding flows in both
// directions so long the conneciton is kept alive
while (true)
{
if (!connectedSocket.IsConnected)
{
break;
}
byte[] requestBytes = null;
if (!receivingClient)
{
receivingClient = true;
try
{
if (!connectedSocket.AsyncReceiveBytes())
{
Console.WriteLine(connectedSocket.LastErrorText + "\r\n");
Thread.Sleep(100);
break;
}
}
catch (AccessViolationException e)
{
Console.WriteLine("## Error (002): " + e);
Thread.Sleep(100);
break;
}
}
// Request starts here, receive from client
if (receivingClient &&
connectedSocket.AsyncReceiveFinished)
{
receivingClient = false;
requestBytes = connectedSocket.AsyncReceivedBytes;
if (requestBytes != null && requestBytes.Length > 0)
{
Console.WriteLine(" >>> rcv: " + responseBytesTotal);
if (responseBytesTotal != 0 &&
File.Exists(PacketRealTimeLog))
{
// Since we are detecting a new request and HTTP is synchronous, we now know the previous
// response has completed, and we measure the aggregated byte count for all its packets
LogPacketLength(PacketRealTimeLog, "--- " + responseBytesTotal,
FileMode.Append, FileAccess.Write, FileShare.Read);
Console.WriteLine("\n----------------\n");
}
// Relay bytes to target server
if (!outboundSocket.SendBytes(requestBytes))
{
Console.WriteLine(connectedSocket.LastErrorText + "\r\n");
Thread.Sleep(100);
break;
}
}
}
// Response starts here
byte[] responseBytes = null;
if (!receivingServer)
{
receivingServer = true;
try
{
if (!outboundSocket.AsyncReceiveBytes())
{
Console.WriteLine("## Error (004) " + outboundSocket.LastErrorText + "\r\n");
Thread.Sleep(100);
continue;
}
}
catch (System.AccessViolationException e)
{
Console.WriteLine("## Error (003): " + e);
Thread.Sleep(100);
break;
}
}
// Write to log file
if (receivingServer &&
outboundSocket.AsyncReceiveFinished)
{
receivingServer = false;
responseBytes = outboundSocket.AsyncReceivedBytes;
if (responseBytes != null && responseBytes.Length > 0)
{
received += responseBytes.Length;
Console.WriteLine("<<" + responseBytes.Length);
sequence++;
// Real time packet log (logging each individual packet length for BREACH)
LogPacketLength(PacketRealTimeLog, sequence + " " + responseBytes.Length,
FileMode.Append, FileAccess.Write, FileShare.Read);
Console.Title = "received: " + received;
responseBytesTotal += responseBytes.Length;
// Relay to client
if (!connectedSocket.SendBytes(responseBytes))
{
Console.WriteLine("## Error (005) " + connectedSocket.LastErrorText + "\r\n");
Thread.Sleep(100);
break;
}
}
else if (connectedSocket.IsConnected &&
!outboundSocket.IsConnected)
{
// We lost one socket, kill it with fire
connectedSocket.Close(10000);
break;
}
}
}
// Log for non-Keep-Alive cases (Connection Closed)
LogPacketLength(PacketLengthLog, received.ToString(),
FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
// Close the connection with the client.
outboundSocket.Close(10000);
connectedSocket.Close(10000);
Console.WriteLine("Socket Closed < " + received);
}
}