Statistics, Cybersecurity [Year 2024 - 25]

Topics on Statistics with intensive computer applications

$ \int_0^t d S_u = \int_0^t \mu(S_u, u) du + \int_0^t\sigma(S_u, u) dW_u $

Supporto al corso e alla didattica telematica, by T. Gastaldi   #Sapienzanonsiferma  #Sapienzadoesnotstop

(Instructor: tommaso.gastaldi@gmail.com,
https://www.datatime.eu/public/cybersecurity/)

Whatsapp group for the students of this course
Invitation to join the Whatsapp group for this course: https://chat.whatsapp.com/Kk3wRGmmxWH9RNUo01zFdX

(When first joining, send a message with your name and id ("matricola"))

    Function CaesarShift(input As String, shift As Integer) As String
        Dim result As New System.Text.StringBuilder()

        For Each ch As Char In input
            If Char.IsUpper(ch) Then
                ' Handle uppercase letters
                Dim offset As Integer = Asc("A")
                Dim shiftedChar As Char = Chr((Asc(ch) - offset + shift) Mod 26 + offset)
                result.Append(shiftedChar)
            ElseIf Char.IsLower(ch) Then
                ' Handle lowercase letters
                Dim offset As Integer = Asc("a")
                Dim shiftedChar As Char = Chr((Asc(ch) - offset + shift) Mod 26 + offset)
                result.Append(shiftedChar)
            ElseIf Char.IsDigit(ch) Then
                ' Handle digits (0-9)
                Dim offset As Integer = Asc("0")
                Dim shiftedChar As Char = Chr((Asc(ch) - offset + shift) Mod 10 + offset)
                result.Append(shiftedChar)
            Else
                ' Non-letter characters are not shifted
                result.Append(ch)
            End If
        Next

        Return result.ToString()
    End Function
	
	//-----------------------
	
	function caesarShift(input, shift) {
    let result = '';

    for (let ch of input) {
        if (ch >= 'A' && ch <= 'Z') {
            // Handle uppercase letters
            let offset = 'A'.charCodeAt(0);
            let shiftedChar = String.fromCharCode(((ch.charCodeAt(0) - offset + shift) % 26 + offset));
            result += shiftedChar;
        } else if (ch >= 'a' && ch <= 'z') {
            // Handle lowercase letters
            let offset = 'a'.charCodeAt(0);
            let shiftedChar = String.fromCharCode(((ch.charCodeAt(0) - offset + shift) % 26 + offset));
            result += shiftedChar;
        } else if (ch >= '0' && ch <= '9') {
            // Handle digits (0-9)
            let offset = '0'.charCodeAt(0);
            let shiftedChar = String.fromCharCode(((ch.charCodeAt(0) - offset + shift) % 10 + offset));
            result += shiftedChar;
        } else {
            // Non-letter characters are not shifted
            result += ch;
        }
    }

    return result;
}

// Example usage
console.log(caesarShift("Hello, World! 123", 3)); // Output: "Khoor, Zruog! 456"


### English (EN) Letter Frequency Distribution
1. **K. M. O’Hara's Studies**: This study provides a comprehensive analysis of letter frequencies in English text. Here's a rough frequency distribution based on various sources:

    - E: 12.70%
    - T: 9.06%
    - A: 8.17%
    - O: 7.51%
    - I: 7.00%
    - N: 6.75%
    - S: 6.33%
    - H: 6.09%
    - R: 5.99%
    - D: 4.25%
    - L: 4.03%
    - C: 2.78%
    - U: 2.76%
    - M: 2.41%
    - W: 2.36%
    - F: 2.23%
    - Y: 1.97%
    - P: 1.93%
    - B: 1.49%
    - V: 0.98%
    - K: 0.77%
    - J: 0.15%
    - X: 0.15%
    - Q: 0.10%
    - Z: 0.07%
   
2. **Wikipedia**: The page on [Letter Frequencies](https://en.wikipedia.org/wiki/Letter_frequency) provides a good overview and includes references to original studies.
   
3. **Cryptography and Information Security**: There are many cryptography textbooks that discuss letter frequency, including authors like Bruce Schneier and William Stallings.

### Italian (ITA) Letter Frequency Distribution 
1. **Italian Language Studies**: Here’s a common frequency distribution for the Italian language:

    - E: 11.79%
    - A: 10.49%
    - I: 9.96%
    - O: 8.76%
    - T: 6.87%
    - N: 6.73%
    - R: 6.52%
    - S: 5.38%
    - L: 5.26%
    - U: 3.33%
    - D: 3.41%
    - C: 3.29%
    - M: 2.51%
    - P: 2.49%
    - H: 0.77%
    - B: 0.81%
    - F: 0.84%
    - X: 0.10%
    - J: 0.12%
    - K: 0.03%
    - Q: 0.52%
    - Z: 0.39%
    - W: 0.00%

 
A -> Q, B -> Z, C -> X, D -> W, E -> V, F -> U, G -> T, 
H -> R, I -> S, J -> P, K -> O, L -> N, M -> M, 
N -> L, O -> K, P -> J, Q -> I, R -> H, S -> G, 
T -> F, U -> E, V -> D, W -> C, X -> B, Y -> A, Z -> Y

Core Functionality in VS:
Imports System.Security.Cryptography.X509Certificates

Primary Certificate Management Classes
- X509Certificate
- X509Certificate2
- X509Store
- X509Chain

RSA Roles:
1. Key Generation
2. Public/Private Key Pair
3. Digital Signature
4. Encryption Mechanism
5. Certificate Signing

RSA Versions/Key Lengths:
1. RSA-1024 (Deprecated)
2. RSA-2048 (Current Standard)
3. RSA-4096 (High Security)
Current SSL/TLS Versions:
 
Active Versions:
1. TLS 1.2 (Widely Used)
2. TLS 1.3 (Latest Recommended)

Deprecated:
- SSL 3.0 (Obsolete)
- TLS 1.0 (Insecure)
- TLS 1.1 (Deprecated)
TLS 1.3 Key Improvements:

tools:
SSL Labs (https://www.ssllabs.com/ssltest/)


SSL (Secure Sockets Layer)
   ↓
TLS (Transport Layer Security)
   - SSL 3.0 → TLS 1.0
   - Developed by IETF
   - Successor to SSL
   
   Certificate Components:
   
- Public Key
- Private Key
- Digital Signature
- Encryption Algorithm
   
RSA in TLS Handshake:

Phases:
1. Key Exchange
2. Initial Authentication
3. Symmetric Key Establishment
Detailed Handshake Process:

Client Hello → Server Hello
↓ RSA Used for:
- Initial Key Exchange
- Certificate Authentication
- Asymmetric Encryption of Shared Secret

After Handshake:
- Switch to Symmetric Encryption (Faster)
- Uses Session Key

Handshake Mechanism:

1. Asymmetric Encryption (RSA)
   - Slow but Secure
   - Used for Initial Key Exchange

2. Symmetric Encryption (AES)
   - Fast
   - Used for Actual Data Transfer
   
Technical Workflow:

Client Steps:
1. Generate Random Premaster Secret
2. Encrypt with Server's Public RSA Key
3. Send Encrypted Premaster Secret

Server Steps:
1. Decrypt Premaster Secret using Private RSA Key
2. Derive Session Keys
3. Establish Symmetric Encryption

Imports System.Net.Http
Imports System.Text.Json
Imports System.Linq

Public Class CertificateAnalyzer
    Private Const API_ENDPOINT As String = "https://crt.sh/?q={0}&output=json"

    ' Main method to run the analysis
    Public Shared Sub Main()
        ' List of domains to analyze
        Dim domains As String() = {"google.com", "microsoft.com", "github.com"}

        ' Analyze certificates for each domain
        For Each domain In domains
            AnalyzeDomainCertificates(domain)
        Next
    End Sub

    ' Method to fetch and analyze certificates for a specific domain
    Public Shared Async Sub AnalyzeDomainCertificates(domain As String)
        Try
            ' Fetch certificate data
            Dim certificates As List(Of Certificate) = Await FetchCertificatesAsync(domain)

            ' Perform statistical analysis
            Dim analysis As CertificateAnalysis = PerformAnalysis(certificates)

            ' Display results
            DisplayResults(domain, analysis)

        Catch ex As Exception
            Console.WriteLine($"Error analyzing {domain}: {ex.Message}")
        End Try
    End Sub

    ' Fetch certificates from crt.sh API
    Private Shared Async Function FetchCertificatesAsync(domain As String) As Task(Of List(Of Certificate))
        Using client As New HttpClient()
            Dim url As String = String.Format(API_ENDPOINT, domain)
            Dim response As String = Await client.GetStringAsync(url)

            ' Parse JSON response
            Dim options As New JsonSerializerOptions()
            options.PropertyNameCaseInsensitive = True

            Dim certData As List(Of Certificate) = 
                JsonSerializer.Deserialize(Of List(Of Certificate))(response, options)

            Return certData
        End Using
    End Function

    ' Perform statistical analysis on certificates
    Private Shared Function PerformAnalysis(certificates As List(Of Certificate)) As CertificateAnalysis
        Dim analysis As New CertificateAnalysis()

        ' Calculate certificate issuer distribution
        analysis.IssuerDistribution = 
            certificates.GroupBy(Function(c) c.Issuer_name)
            .Select(Function(g) New With {
                .Issuer = g.Key,
                .Count = g.Count()
            })
            .OrderByDescending(Function(x) x.Count)
            .ToList()

        ' Calculate average validity period
        analysis.AverageValidityDays = 
            certificates.Average(Function(c) 
                (c.Not_after - c.Not_before).TotalDays)

        ' Count unique key lengths
        analysis.KeyLengthDistribution = 
            certificates.GroupBy(Function(c) c.Pubkey_size)
            .Select(Function(g) New With {
                .KeyLength = g.Key,
                .Count = g.Count()
            })
            .OrderBy(Function(x) x.KeyLength)
            .ToList()

        Return analysis
    End Function

    ' Display analysis results
    Private Shared Sub DisplayResults(domain As String, analysis As CertificateAnalysis)
        Console.WriteLine($"Certificate Analysis for {domain}")
        Console.WriteLine("----------------------------")

        ' Display issuer distribution
        Console.WriteLine("Certificate Issuer Distribution:")
        For Each issuer In analysis.IssuerDistribution
            Console.WriteLine($"{issuer.Issuer}: {issuer.Count} certificates")
        Next

        ' Display average validity
        Console.WriteLine($"Average Certificate Validity: {analysis.AverageValidityDays:F2} days")

        ' Display key length distribution
        Console.WriteLine("Key Length Distribution:")
        For Each keyLength In analysis.KeyLengthDistribution
            Console.WriteLine($"{keyLength.KeyLength} bits: {keyLength.Count} certificates")
        Next
    End Sub

    ' Certificate data model
    Public Class Certificate
        Public Property Issuer_name As String
        Public Property Not_before As Date
        Public Property Not_after As Date
        Public Property Pubkey_size As Integer
    End Class

    ' Analysis results container
    Public Class CertificateAnalysis
        Public Property IssuerDistribution As List(Of Object)
        Public Property AverageValidityDays As Double
        Public Property KeyLengthDistribution As List(Of Object)
    End Class
End Class