A Cifra de César usa de um sistema de substituição monoalfabético, onde cada letra leva um valor (a=0,z=25) que é substituído modularmente com a soma de uma chave(0,25).

C=E(k,p) = (k+p)mod26

Esta cifra é facilmente quebrada aplicando um analise de frequência nos caracteres do texto cifrado.

O script abaixo recebe duas entradas uma chave(0,25) e um texto claro podendo ter espaços e letras maiúsculas e minusculas, através disso gera um texto cifrado.

A criptoanálise é feita achando os caracteres de texto cifrado com maior repetições e substituindo com os caracteres que mais aparecem na linguá Portuguesa, gerando 5 possíveis textos claro.

Há um problema nessa criptoanalise, apesar da cifra de César ser fácil quebrar se o texto claro for muito pequeno dificultara bons resultados imediatos.

• Download cifra_cesar_1-0.c
• Enviar nova versão

Esconder código-fonte

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>

typedef struct sDados
   {
   int chave;
   int max_freq[5];
   int rep[26];
   char alf[26];
   char txt_claro[200];
   char txt_cifrado[200];
   char pos_txt[5][200];
   }Dados;

int zerar_txts(Dados * dados)
   {
   int i;
   strcpy(dados->txt_claro,"");
   strcpy(dados->txt_cifrado,"");
   for(i=0;i<5;i++)
      {
      strcpy(dados->pos_txt[i],"");
      }
   }

int iniciar_dados(Dados * dados)
   {
   int i;
   dados->max_freq[0] = 97;
   dados->max_freq[1] = 101;
   dados->max_freq[2] = 105;
   dados->max_freq[3] = 111;
   dados->max_freq[4] = 115;
   strcpy(dados->alf,"abcdefghijklmnopqrstuvwxyz");
   for(i=0;i<26;i++)
      {
      dados->rep[i] = 0;
      }
   }

void imprime(Dados * dados)
   {
   int i, n;
   printf("\nChave: %d\n",dados->chave);
   printf("Texto Claro: %s\n",dados->txt_claro);
   printf("Texto Cifrado: %s\n\n",dados->txt_cifrado);
   printf("Repeticoes");
   for(i=0;i<10;i++)
      {
      printf(" %c = %d |",dados->alf[i],dados->rep[i]);
      }
   printf("\n\nPossiveis texto-claro\n");
   for(n=0;n<5;n++)
      {
      for(i=0;i<strlen(dados->txt_cifrado);i++)
         {
         printf("%c",dados->pos_txt[n][i]);
         }
      printf("\n");
      }
   }

int M_m(Dados * dados)
   {
   int i;
   for(i=0;i<strlen(dados->txt_claro);i++)
      {
      dados->txt_claro[i] = tolower(dados->txt_claro[i]);
      }
   }

int cifrar(Dados * dados)
   {
   int i, c;
   for(i=0;i<strlen(dados->txt_claro);i++)
      {
      if(dados->txt_claro[i] == ' ')
         {
         dados->txt_cifrado[i] = ' ';
         }
      else
         {
         c=(int)dados->txt_claro[i]+dados->chave;
         if(c > 122)
            {
            c = c-26;
            dados->txt_cifrado[i] = c;
            }
         else
            {
            dados->txt_cifrado[i] = c;
            }
         }
      }
   }

int conta_rep(Dados * dados)
   {
   int i, n;
   for(i=0;i<26;i++)
      {
      for(n=0;n<strlen(dados->txt_cifrado);n++)
         {
         if(dados->alf[i]==dados->txt_cifrado[n])
            {
            dados->rep[i]++;
            }
         }
      }
   }

int ord_rep(Dados * dados)
   {
   int i, n, v_max;
   char c;
   for(i=0;i<26;i++)
      {
      for(n=(i+1);n<26;n++)
         {
         if(dados->rep[i]<dados->rep[n])
            {
            v_max = dados->rep[i];
            c = dados->alf[i];
            dados->rep[i] = dados->rep[n];
            dados->alf[i] = dados->alf[n];
            dados->rep[n] = v_max;
            dados->alf[n] = c;
            }
         }
      }
   }

int cripto_analise(Dados * dados)
   {
   int i, n,cifra, tc;
   char c;
   c = dados->alf[0];
   for(n=0;n<5;n++)
      {
      cifra = (int)c - dados->max_freq[n];
      for(i=0;i<strlen(dados->txt_cifrado);i++)
         {
         if(dados->txt_cifrado[i] == ' ')
            {
            dados->pos_txt[n][i] = ' ';
            }
         else
            {
            tc =(int)dados->txt_cifrado[i]-cifra;
            if(tc < 97)
               {
               tc = tc + 26;
               dados->pos_txt[n][i] = tc;
               }
            if(tc > 122)
               {
               tc = tc - 26;
               dados->pos_txt[n][i] = tc;
               }
            else
               {
               dados->pos_txt[n][i] = tc;
               }
            }
         }
      }
   }

int menu(Dados * dados)
   {
   int op;
   do
      {
      printf("\n1-)Incluir chave\n");
      printf("2-)Incluir texto\n");
      printf("3-)Cifrar\n");
      printf("4-)Cripto-Analise\n");
      printf("5-)Imprimir\n");
      printf("0-)Sair\n");
      scanf("%d",&op);
      switch(op)
         {
         case 1:
            {
            do
               {
               printf("Digite a chave\n");
               scanf("%d",&dados->chave);
               }while(dados->chave > 25);
            break;
            }
         case 2:
            {
            printf("Digite a mensagem\n");
            setbuf(stdin,NULL);
            scanf("%[^\n]",dados->txt_claro);
            M_m(dados);
            break;
            }
         case 3:
            {
            cifrar(dados);
            break;
            }
         case 4:
            {
            iniciar_dados(dados);
            conta_rep(dados);
            ord_rep(dados);
            cripto_analise(dados);
            break;
            }
         case 5:
            {
            imprime(dados);
            break;
            }
         }
      }while(op!=0);
   }

int main()
   {
   Dados * dados = (Dados *)malloc(sizeof(Dados));
   menu(dados);
   free(dados);
   }

Fork bomb em C

Cifra de César!

Exploit para kernel 2.6.12-rc4

Faz um crash no Kernel do Linux

Script para fazer ataque DoS - use apenas como testes com sistemas de segurança

Nenhum comentário foi encontrado.