Życzymy dobrej zabawy.

{
 *******************************************************
 ** Przykładowa aplikacja obrazująca sposób działania **
 ** asymetrycznego systemu kodowania informacji RSA.  **
 ** ------------------------------------------------- **
 **           (C)2020 mgr Jerzy Wałaszek              **
 **            I Liceum Ogólnokształcące              **
 **          im. Kazimierza Brodzińskiego             **
 **                   w Tarnowie                      **
 *******************************************************
}

program rsa;

// Procedura oczekuje na naciśnięcie
// klawisza Enter, po czym czyści ekran
// okna konsoli
//-------------------------------------
procedure Czekaj;
var
  i : integer;
begin
  writeln;
  writeln('Zapisz te dane i nacisnij Enter');
  readln;
  for i := 1 to 500 do writeln;
end;

// Funkcja obliczająca NWD
// dla dwóch liczb
//------------------------
function nwd(a, b : integer) : integer;
var
  t : integer;
begin
  while b <> 0 do
  begin
    t := b;
    b := a mod b;
    a := t
  end;
  nwd := a
end;

// Funkcja obliczania odwrotności
// modulo n
//-------------------------------
function odwr_mod(a, n : integer) : integer;
var
  a0, n0, p0, p1, q, r, t : integer;
begin
  p0 := 0; p1 := 1; a0 := a; n0 := n;
  q  := n0 div a0;
  r  := n0 mod a0;
  while r > 0 do
  begin
    t := p0-q*p1;
    if t >= 0 then
      t := t mod n
    else
      t := n-((-t) mod n);
    p0 := p1; p1 := t;
    n0 := a0; a0 := r;
    q  := n0 div a0;
    r  := n0 mod a0;
  end;
  odwr_mod := p1;
end;

// Procedura generowania kluczy RSA
//---------------------------------
procedure klucze_RSA;
const
  tp : array [0..9] of integer
    = (11, 13, 17, 19, 23, 29, 31, 37, 41, 43);
var
  p, q, phi, n, e, d : integer;
begin
  writeln('Generowanie kluczy RSA');
  writeln('----------------------');
  writeln;

  // generujemy dwie różne, 
  // losowe liczby pierwsze
  repeat
    p := tp[random(10)];
    q := tp[random(10)];
  until p <> q;

  phi := (p-1)*(q-1);
  n   := p*q;

  // wyznaczamy wykładniki e i d
  e := 3;
  while nwd(e, phi) <> 1 do inc(e, 2);
  d := odwr_mod(e, phi);

  // gotowe, wypisujemy klucze
  writeln('KLUCZ PUBLICZNY');
  writeln('wykladnik e = ', e);
  writeln('    modul n = ', n);
  writeln;
  writeln('KLUCZ PRYWATNY');
  writeln('wykladnik d = ', d);
  Czekaj;
end;

// Funkcja oblicza modulo potęgę podanej liczby
//---------------------------------------------
function pot_mod(a, w, n : integer) : integer;
var
  pot, wyn, q  : integer;
begin

  // wykładnik w rozbieramy na sumę potęg 2.
  // Dla reszt niezerowych tworzymy iloczyn
  // potęg a modulo n.
  pot := a; wyn := 1; q := w;
  while q > 0 do
  begin
    if(q mod 2) = 1 then wyn := (wyn*pot) mod n;
    pot := (pot*pot) mod n;    // kolejna potęga
    q := q div 2;
  end;
  pot_mod := wyn;
end;

// Procedura kodowania danych RSA
//-------------------------------
procedure kodowanie_RSA;
var
  e, n, t : integer;
begin
  writeln('Kodowanie danych RSA');
  writeln('--------------------');
  writeln;
  write ('Podaj wykladnik = '); readln(e);
  write ('    Podaj modul = '); readln(n);
  writeln('----------------------------------');
  writeln;
  write ('Podaj kod RSA   = '); readln(t);
  writeln;
  writeln('Wynik kodowania = ', 
           pot_mod(t, e, n));
  Czekaj;
end;

// ********************
// ** Program główny **
// ********************

var
  w : integer;

begin
  randomize;
  repeat
    writeln('System szyfrowania danych RSA');
    writeln('-----------------------------');
    writeln(' (C)2012 mgr Jerzy Walaszek ');
    writeln;
    writeln('MENU');
    writeln('====');
    writeln('[0]-Koniec pracy programu');
    writeln('[1]-Generowanie kluczy RSA');
    writeln('[2]-Kodowanie RSA');
    writeln;
    write ('Jaki jest twoj wybor? (0, 1 lub 2) : ');
    readln(w);
    writeln; writeln; writeln;
    case w of
      1 : klucze_RSA;
      2 : kodowanie_RSA;
    end;
    writeln; writeln; writeln;
  until w = 0;
end.

/*
 *******************************************************
 ** Przykładowa aplikacja obrazująca sposób działania **
 ** asymetrycznego systemu kodowania informacji RSA.  **
 ** ------------------------------------------------- **
 **           (C)2020 mgr Jerzy Wałaszek              **
 **            I Liceum Ogólnokształcące              **
 **          im. Kazimierza Brodzińskiego             **
 **                   w Tarnowie                      **
 *******************************************************
*/

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>

using namespace std;

// Funkcja czeka na dowolny klawisz i czyści ekran
//------------------------------------------------
void czekaj(void)
{
  char c[1];

  cout << "\nZapisz te dane\n\n";
  cin.getline(c, 1);
  cin.getline(c, 1);	
  for(int i = 1; i < 500; i++)
    cout << endl;
}

// Funkcja obliczająca NWD dla dwóch liczb
//----------------------------------------
int nwd(int a, int b)
{
  int t;

  while(b != 0)
  {
    t = b;
    b = a%b;
    a = t;
  };
  return a;
}

// Funkcja obliczania odwrotności modulo n
//----------------------------------------
int odwr_mod(int a, int n)
{
  int a0, n0, p0, p1, q, r, t;

  p0 = 0; p1 = 1; a0 = a; n0 = n;
  q  = n0/a0;
  r  = n0%a0;
  while(r > 0)
  {
    t = p0-q*p1;
    if(t >= 0)
      t = t%n;
    else
      t = n-((-t)%n);
    p0 = p1; p1 = t;
    n0 = a0; a0 = r;
    q  = n0/a0;
    r  = n0%a0;
  }
  return p1;
}

// Procedura generowania kluczy RSA
//---------------------------------
void klucze_RSA()
{
  const int tp[10]
    = {11, 13, 17, 19, 23, 29, 31, 37, 41, 43};
  int p, q, phi, n, e, d;

  cout << "Generowanie kluczy RSA\n"
          "----------------------\n\n";

  // generujemy dwie różne, losowe liczby pierwsze
  do
  {
    p = tp[rand()%10];
    q = tp[rand()%10];
  } while(p == q);
  phi = (p-1)*(q-1);
  n   = p*q;

  // wyznaczamy wykładniki e i d
  for(e = 3; nwd(e, phi) != 1; e += 2);
  d = odwr_mod(e, phi);

  // gotowe, wypisujemy klucze
  cout << "KLUCZ PUBLICZNY\n"
          "wykladnik e = " << e
       << "\n    modul n = " << n
       << "\n\nKLUCZ PRYWATNY\n"
          "wykladnik d = " << d << endl;
  czekaj();
}

// Funkcja oblicza modulo potęgę podanej liczby
//---------------------------------------------
int pot_mod(int a, int w, int n)
{
  int pot, wyn, q;

  // wykładnik w rozbieramy na sumę potęg 2
  // przy pomocy algorytmu Hornera. Dla reszt
  // niezerowych tworzymy iloczyn potęg a modulo n.
  pot = a; wyn = 1;
  for(q = w; q > 0; q /= 2)
  {
    if(q%2) wyn = (wyn*pot)%n;
    pot = (pot*pot)%n; // kolejna potęga
  }
  return wyn;
}

// Procedura kodowania danych RSA
//-------------------------------
void kodowanie_RSA()
{
  int e, n, t;

  cout << "Kodowanie danych RSA\n"
          "--------------------\n\n"
          "Podaj wykladnik = "; cin  >> e;
  cout << "    Podaj modul = "; cin  >> n;
  cout << "----------------------------------\n\n"
          "Podaj kod RSA   = "; cin  >> t;
  cout << "\nWynik kodowania = "
       << pot_mod(t, e, n) << endl;

  czekaj();
}

// ********************
// ** Program główny **
// ********************

int main()
{
  int w;

  srand(time(NULL));

  do
  {
    cout << "System szyfrowania danych RSA\n"
            "-----------------------------\n"
            " (C)2012 mgr Jerzy Walaszek\n\n"
            "MENU\n"
            "====\n"
            "[0]-Koniec pracy programu\n"
            "[1]-Generowanie kluczy RSA\n"
            "[2]-Kodowanie RSA\n\n"
            "Jaki jest twoj wybor? (0, 1 lub 2) : ";
    cin  >> w;
    cout << "\n\n\n";
    switch(w)
    { 
      case 1 : klucze_RSA(); break;
      case 2 : kodowanie_RSA(); break;
    }
    cout << "\n\n\n";
  } while(w != 0);

  return 0;
}

/'*******************************************************
  ** Przykładowa aplikacja obrazująca sposób działania **
  ** asymetrycznego systemu kodowania informacji RSA.  **
  ** ------------------------------------------------- **
  **           (C)2020 mgr Jerzy Wałaszek              **
  **            I Liceum Ogólnokształcące              **
  **          im. Kazimierza Brodzińskiego             **
  **                   w Tarnowie                      **
  ******************************************************* '/

Declare Sub klucze_RSA()
Declare Sub kodowanie_RSA()

Dim w As Integer

Randomize
Do
  Print "System szyfrowania danych RSA"
  Print "-----------------------------"
  Print " (C)2012 mgr Jerzy Walaszek "
  Print
  Print "MENU"
  Print "===="
  Print "[0]-Koniec pracy programu"
  Print "[1]-Generowanie kluczy RSA"
  Print "[2]-Kodowanie RSA"
  Print
  Input "Jaki jest twoj wybor? (0, 1 lub 2) : ", w
  Print: Print: Print
  If w = 1 Then
    klucze_RSA()
  Elseif w = 2 Then
    kodowanie_RSA()
  End If
  Print: Print: Print
Loop Until w = 0
End

' Procedura oczekuje na naciśnięcie klawisza Enter
' po czym czyści ekran okna konsoli
'-------------------------------------------------
Sub Czekaj()
  Print
  Print "Zapisz te dane i nacisnij Enter"
  Getkey
  Cls
End Sub

' Funkcja obliczająca NWD dla dwóch liczb
'----------------------------------------
Function nwd(Byval a As Integer, _
             Byval b As Integer) _
             As Integer
  Dim t As Integer
  While b
    t = b
    b = a Mod b
    a = t
  Wend
  nwd = a
End Function

' Funkcja obliczania odwrotności modulo n
'----------------------------------------
Function odwr_mod(Byval a As Integer, _
                  Byval b As Integer) _
                  As Integer
  Dim As Integer u, w, x, z, q
  u = 1: w = a
  x = 0: z = b
  While w
    If w < z Then
      q = u: u = x: x = q
      q = w: w = z: z = q
    End If
    q = w\z
    u = u-q*x
    w = w-q*z
  Wend
  If x < 0 Then x += b
  odwr_mod = x
End Function

' Procedura generowania kluczy RSA
'---------------------------------
Sub klucze_RSA()
  Dim tp (9) As Integer_
    = {11, 13, 17, 19, 23, 29, 31, 37, 41, 43}
  Dim As Integer p, q, phi, n, e, d

  Print "Generowanie kluczy RSA"
  Print "----------------------"
  Print

  ' generujemy dwie różne, losowe liczby pierwsze
  Do
    p = tp(Int(Rnd*10))
    q = tp(Int(Rnd*10))
  Loop Until p <> q
  phi = (p-1)*(q-1)
  n   = p*q

  ' wyznaczamy wykładniki e i d
  e = 3
  While nwd(e, phi) <> 1
    e += 2
  Wend
  d = odwr_mod(e, phi)

  ' gotowe, wypisujemy klucze
  Print "KLUCZ PUBLICZNY"
  Print "wykladnik e = ";e
  Print "    modul n = ";n
  Print
  Print "KLUCZ PRYWATNY"
  Print "wykladnik d = ";d
  Czekaj()
End Sub

' Funkcja oblicza modulo potęgę podanej liczby
'---------------------------------------------
Function pot_mod (Byval a As Integer, _
                  Byval w As Integer, _
                  Byval n As Integer) _
                  As Integer
  Dim As Integer pot, wyn, q

  ' wykładnik w rozbieramy na sumę potęg 2. Dla reszt
  ' niezerowych tworzymy iloczyn potęg a modulo n.
  pot = a: wyn = 1: q = w
  While q > 0
    if(q Mod 2) = 1 Then wyn = (wyn*pot) Mod n
    pot = (pot*pot) Mod n ' kolejna potęga
    q   = q\2
  Wend
  pot_mod = wyn
End Function

' Procedura kodowania danych RSA
'-------------------------------
Sub kodowanie_RSA()
  Dim As Integer e, n, t
 
  Print "Kodowanie danych RSA"
  Print "--------------------"
  Print
  Input "Podaj wykladnik = "; e
  Input "    Podaj modul = "; n
  Print "----------------------------------"
  Print
  Input "Podaj kod RSA   = "; t
  Print
  Print "Wynik kodowania = "; pot_mod(t, e, n)
  Czekaj()
End Sub

# *******************************************************
# ** Przykładowa aplikacja obrazująca sposób działania **
# ** asymetrycznego systemu kodowania informacji RSA.  **
# ** ------------------------------------------------- **
# **           (C)2024 mgr Jerzy Wałaszek              **
# **            I Liceum Ogólnokształcące              **
# **          im. Kazimierza Brodzińskiego             **
# **                   w Tarnowie                      **
# *******************************************************

import random
from os import system, name


# Funkcja czeka na dowolny klawisz i czyści ekran
# ------------------------------------------------
def czekaj():
    print()
    input("Zapisz te dane i naciśnij Enter")
    if name == "nt":
        _ = system("cls")
    else:
        _ = system("clear")


# Funkcja obliczająca NWD dla dwóch liczb
# ----------------------------------------
def nwd(a, b):
    while b != 0:
        t = b
        b = a % b
        a = t
    return a


# Funkcja obliczania odwrotności modulo n
# ----------------------------------------
def odwr_mod(a, n):
    p0 = 0
    p1 = 1
    a0 = a
    n0 = n
    q = n0 // a0
    r = n0 % a0
    while r > 0:
        t = p0 - q * p1
        if t >= 0:
            t %= n
        else:
            t = n - ((-t) % n)
            p0 = p1
            p1 = t
            n0 = a0
            a0 = r
            q = n0 // a0
            r = n0 % a0
    return p1


# Procedura generowania kluczy RSA
# ---------------------------------
def klucze_rsa():
    tp = [11, 13, 17, 19, 23, 29, 31, 37, 41, 43]
    print("Generowanie kluczy RSA")
    print("----------------------")
    print()
    # generujemy dwie różne, losowe liczby pierwsze
    while True:
        p = tp[random.randrange(10)]
        q = tp[random.randrange(10)]
        if p != q: break
    phi = (p - 1) * (q - 1)
    n = p * q
    # wyznaczamy wykładniki e i d
    e = 3
    while nwd(e, phi) != 1:
        e += 2
    d = odwr_mod(e, phi)
    # gotowe, wypisujemy klucze
    print("KLUCZ PUBLICZNY")
    print("wykładnik e =", e)
    print("    moduł n =", n)
    print()
    print("KLUCZ PRYWATNY")
    print("wykładnik d =", d)
    czekaj()


# Funkcja oblicza modulo potęgę podanej liczby
# ---------------------------------------------
def pot_mod(a, w, n):
    # wykładnik w rozbieramy na sumę potęg 2
    # przy pomocy algorytmu Hornera. Dla reszt
    # niezerowych tworzymy iloczyn potęg a modulo n.
    pot, wyn, q = a, 1, w
    while q > 0:
        if q % 2 != 0:
            wyn = (wyn * pot) % n
        pot = (pot * pot) % n  # kolejna potęga
        q //= 2
    return wyn


# Procedura kodowania danych RSA
# -------------------------------
def kodowanie_rsa():
    print("Kodowanie danych RSA")
    print("--------------------")
    print()
    e = int(input("Podaj wykładnik = "))
    n = int(input("    Podaj moduł = "))
    print("----------------------------------")
    print()
    t = int(input("Podaj kod RSA   = "))
    print()
    print("\nWynik kodowania =", pot_mod(t, e, n))
    czekaj()


# ********************
# ** Program główny **
# ********************

while True:
    print("System szyfrowania danych RSA")
    print("-----------------------------")
    print(" (C)2024 mgr Jerzy Wałaszek")
    print()
    print("MENU")
    print("====")
    print("[0]-Koniec pracy programu")
    print("[1]-Generowanie kluczy RSA")
    print("[2]-Kodowanie RSA")
    print()
    w = int(input("Jaki jest twój wybór? (0, 1 lub 2) : "))
    print()
    print()
    print()
    match w:
        case 0:
            break
        case 1:
            klucze_rsa()
        case 2:
            kodowanie_rsa()
    print()
    print()
    print()