
Contents
C# Basics
Data Types
C# provides a number of built-in data types, including integers, floating-point numbers, booleans, and characters. Here are some examples:
int age = 25;
float temperature = 98.6f;
bool isAlive = true;
char firstInitial = 'J';
In this code, we declare and initialize variables of type int
, float
, bool
, and char
. The int
and float
types are used for storing numerical values, while the bool
type is used for storing true/false values. The char
type is used for storing single characters.
Variables and Constants
In C#, we can declare and initialize variables and constants. Variables are values that can change, while constants are values that cannot change. Here are some examples:
int count = 0; // variable
const float Pi = 3.14159f; // constant
In this code, we declare and initialize a variable named count
with a value of 0
, and a constant named Pi
with a value of 3.14159f
.
Control Flow Statements
C# provides a number of control flow statements, including if
statements, for
loops, and while
loops. Here are some examples:
int age = 25;
if (age >= 18)
{
Console.WriteLine("You are an adult.");
}
else
{
Console.WriteLine("You are not an adult.");
}
for (int i = 0; i < 10; i++)
{
Console.WriteLine(i);
}
int j = 0;
while (j < 10)
{
Console.WriteLine(j);
j++;
}
In this code, we use an if
statement to check if age
is greater than or equal to 18
, a for
loop to print the numbers from 0
to 9
, and a while
loop to print the numbers from 0
to 9
again.
Functions
In C#, we can define functions to encapsulate code and make it reusable. Here’s an example:
int Add(int a, int b)
{
return a + b;
}
int result = Add(3, 5);
Console.WriteLine(result); // prints "8"
In this code, we define a function named Add
that takes two integer parameters and returns their sum. We then call the Add
function with the arguments 3
and 5
, and store the result in a variable named result
. Finally, we print the value of result
to the console, which is 8
.
Classes and Objects
In C#, we can define classes to define our own data types. We can then create objects of those classes to store data and perform operations on that data. Here’s an example:
class Person
{
public string Name { get; set; }
public int Age { get; set; }
public void SayHello()
{
Console.WriteLine("Hello, my name is " + Name + " and I am " + Age + " years old.");
}
}
Person person = new Person();
person.Name = "John";
person.Age = 25;
person.SayHello(); // prints "Hello, my name is John and I am 25 years old."
In this code, we define a class named Person
that has two properties (Name
and Age
) and a method (SayHello
). We then create an object of the Person
class, set its properties, and call
Example of C# code for encrypting arbitrary files
The code below will encrypt arbitrary files with a random generated key. The files will then be sent over FTP to a remote server. The key is then sent over mail to a specified address
// These lines import the necessary namespaces for the program to work: System (which provides the basic functionality of the .NET framework), System.IO (which provides file input/output functionality), System.Security.Cryptography (which provides cryptographic functionality), System.Net (which provides network functionality), and System.Net.Mail (which provides email functionality).
using System;
using System.IO;
using System.Security.Cryptography;
using System.Net;
using System.Net.Mail;
// These lines define the Program class and the Main method, which is the entry point of the program.
class Program
{
static void Main()
{
// Prompt the user to enter the path to the file to be encrypted.
Console.WriteLine("Enter the path to the file to be encrypted:");
string filePath = Console.ReadLine();
// Prompt the user to enter a key for encryption.
Console.WriteLine("Enter a key for encryption:");
string key = Console.ReadLine();
//These lines generate a random salt for the encryption algorithm using the RNGCryptoServiceProvider class from the System.Security.Cryptography namespace. The salt is a random value used to ensure that two identical plaintexts don't result in identical ciphertexts.
// Generate a random salt for the encryption algorithm.
byte[] salt = new byte[16];
using (var rng = new RNGCryptoServiceProvider())
{
rng.GetBytes(salt);
}
// These lines derive a key and initialization vector (IV) from the user-provided key and salt using the Rfc2898DeriveBytes class, which implements the PBKDF2 key derivation function. PBKDF2 takes a password and a salt, and generates a key that can be used with an encryption algorithm. The derivedKey variable contains the 256-bit key, and the iv variable contains the 128-bit IV.
// Derive a key and initialization vector from the user-provided key and salt.
byte[] derivedKey, iv;
using (var pbkdf2 = new Rfc2898DeriveBytes(key, salt, 10000))
{
derivedKey = pbkdf2.GetBytes(32); // 256-bit key
iv = pbkdf2.GetBytes(16); // 128-bit IV
}
// These lines derive a key and initialization vector (IV) from the user-provided key and salt using the Rfc2898DeriveBytes class, which implements the PBKDF2 key derivation function. PBKDF2 takes a password and a salt, and generates a key that can be used with an encryption algorithm. The derivedKey variable contains the 256-bit key, and the iv variable contains the 128-bit IV.
// Encrypt the file using AES encryption.
using (var aes = Aes.Create())
{
aes.Key = derivedKey;
aes.IV = iv;
using (var inputFileStream = File.OpenRead(filePath))
using (var outputFileStream = File.Create(filePath + ".enc"))
using (var cryptoStream = new CryptoStream(outputFileStream, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
inputFileStream.CopyTo(cryptoStream);
}
}
// Send the encrypted file over FTP to a remote server.
string ftpServer = "ftp://example.com/";
string ftpUsername = "username";
string ftpPassword = "password";
string ftpRemotePath = "/encrypted/";
string fileName = Path.GetFileName(filePath) + ".enc";
using (var client = new WebClient())
{
client.Credentials = new NetworkCredential(ftpUsername, ftpPassword);
client.UploadFile(ftpServer + ftpRemotePath + fileName, "STOR", filePath + ".enc");
}
// Send the key over email to a specified address.
string fromAddress = "sender@example.com";
string toAddress = "recipient@example.com";
string subject = "Encryption Key";
string body = "Here's the key for the encrypted file: " + key;
using (var smtpClient = new SmtpClient("smtp.example.com", 587))
{
smtpClient.Credentials = new NetworkCredential("username", "password");
smtpClient.EnableSsl = true;
smtpClient.Send(fromAddress, toAddress, subject, body);
}
// Delete the encrypted file from the local machine.
File.Delete(filePath + ".enc");
}
}
Decrypting files
You need the key that is sent to the email address in order to decrypt the files.
using System;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Security.Cryptography;
class Program
{
static void Main()
{
// Prompt the user to enter the path to the encrypted file.
Console.WriteLine("Enter the path to the encrypted file:");
string encryptedFilePath = Console.ReadLine();
// Prompt the user to enter the key for decryption.
Console.WriteLine("Enter the key for decryption:");
string key = Console.ReadLine();
// Retrieve the salt used for encryption from the first 16 bytes of the encrypted file.
byte[] salt = new byte[16];
using (var inputFileStream = File.OpenRead(encryptedFilePath))
{
inputFileStream.Read(salt, 0, salt.Length);
}
// Derive the key and initialization vector (IV) from the user-provided key and salt using the Rfc2898DeriveBytes class.
byte[] derivedKey, iv;
using (var pbkdf2 = new Rfc2898DeriveBytes(key, salt, 10000))
{
derivedKey = pbkdf2.GetBytes(32); // 256-bit key
iv = pbkdf2.GetBytes(16); // 128-bit IV
}
// Decrypt the file using AES encryption.
using (var aes = Aes.Create())
{
aes.Key = derivedKey;
aes.IV = iv;
using (var inputFileStream = File.OpenRead(encryptedFilePath))
using (var outputFileStream = File.Create(Path.GetFileNameWithoutExtension(encryptedFilePath)))
using (var cryptoStream = new CryptoStream(inputFileStream, aes.CreateDecryptor(), CryptoStreamMode.Read))
{
cryptoStream.CopyTo(outputFileStream);
}
}
Console.WriteLine("File decrypted successfully.");
}
}