Mais um blog inútil.

Useless

Agosto 3, 2018

Arvorezinha em Progress 4GL

Arquivado em: arvorezinha, coding, drama, fail, serious-business, useless, work — madinfo @ 16:35

Boa tarde,

Já não blolava á anos… resolvi blolar sobre uma linguagem que se chama Progress 4GL ou OpenEdge Advanced Business Language (OpenEdge ABL).
É uma linguagem linda que mais se devia chamar REGRESS em vez de Progress.

Aqui fica o código:

DEFINE VARIABLE i AS INTEGER NO-UNDO.
&SCOPED-DEFINE NumLoops  5    
DEFINE VARIABLE charz AS CHARACTER NO-UNDO INITIAL "*".

 REPEAT i = 1 TO {&NumLoops}:
     
     DISPLAY charz.
     charz = charz + "*".
END.


MESSAGE "Fim!!"
    VIEW-AS ALERT-BOX INFO BUTTONS OK.

Digam lá que não é a melhor coisa do mundo ?

Novembro 11, 2013

Arvorezinha v1 e v2 - Lisp

Arquivado em: arvorezinha, coding, useless — falso @ 10:55

Ora viva amigos!

Tive uma submissão de arvorezinhas de um comparsa dos mirques, o _Lone_Wolf_ , ele presenteou-nos com as duas versões em Lisp.

v1

(defun arvorezinha (count) (loop for i from 1 to count do (princ(concatenate 'string (make-string i :initial-element #\*) (format t "~%" #\linefeed)))))

v2

(defun arvorezinha2 (height) (loop
    (loop for i from 1 to height do (princ(concatenate 'string (make-string (- height i -1) :initial-element #\ ) (make-string (- (* 2 i) 1) :initial-element #\*) (format t "~%" #\linefeed))))    
    (setf trunk (floor (/ (- (* height 2) 1) 2)))
    (loop for i from 1 to (/ height 2) do
      (if (/= (mod height 2) 0)
          (princ(concatenate 'string (make-string (+ (/ trunk 2) 1) :initial-element #\ ) (make-string (+ trunk 1) :initial-element #\#) (format t "~%" #\linefeed)))
          (princ(concatenate 'string (make-string (+ (ceiling (/ trunk 2)) 1) :initial-element #\ ) (make-string trunk :initial-element #\#) (format t "~%" #\linefeed)))
      )
    )
    (return '*****)
))

Pode-se experimentar o codigo aqui: http://www.compileonline.com/execute_lisp_online.php
Já agora, o que está aí são só funções pelo que estive a ver. Então para experimentar corre-se o seguinte:

;;v1
(arvorezinha 5)
;;v2
(arvorezinha2 5)

Novembro 8, 2012

A Água

Arquivado em: lulz, useless — sadik @ 22:58

Boas noites caros amigos das internets.

Venho por este meio, usar este lindo blol para publicar o seguinte poema do grande Bocage.

“A Água”

Meus senhores eu sou a água
que lava a cara, que lava os olhos
que lava a rata e os entrefolhos
que lava a nabiça e os agriões
que lava a piça e os colhões
que lava as damas e o que está vago
pois lava as mamas e por onde cago.

Meus senhores aqui está a água
que rega a salsa e o rabanete
que lava a língua a quem faz minete
que lava o chibo mesmo da raspa
tira o cheiro a bacalhau rasca
que bebe o homem, que bebe o cão
que lava a cona e o berbigão.

Meus senhores aqui está a água
que lava os olhos e os grelinhos
que lava a cona e os paninhos
que lava o sangue das grandes lutas
que lava sérias e lava putas
apaga o lume e o borralho
e que lava as guelras ao caralho

Meus senhores aqui está a água
que rega rosas e manjericos
que lava o bidé, que lava penicos
tira mau cheiro das algibeiras
dá de beber ás fressureiras
lava a tromba a qualquer fantoche e
lava a boca depois de um broche.

Junho 20, 2012

Blocos de endereçamento IP por país

Arquivado em: coding, useless — thread @ 05:46

Bom dia malta das inutilidades.

Venho aqui partilhar mais uma das minhas muitas inutilidades… um escripe em pitão inútil que faz a consulta online de ip address blocks atribuidos a um determinado pais e devolve uma lista dos mesmos.
No site onde faço o request, têm a versão csv disponivel também… mas isso não tem piada e não é inútil pois não poderia usar um html parser e a coisa ia ficar assim meia deslavada e desenquadrada no blol.

A sintaxe não poderia ser mais simples:

$ ./escripe.py acronimo

Eg:

$ ./escripe.py pt
(e receberão uma lista de blocos (um bloco por linha) no formato “from X to Y”)

Cá vai:

#!/usr/bin/python

import sys
import httplib
import re
from HTMLParser import HTMLParser

raw_block_list = []

class ORHTMLParser(HTMLParser):
        def handle_data(self, data):
                pat = re.search(r"^((\d{1,3}\.){3,3}\d{1,3})$", data.strip(' '))

                if pat:
                        raw_block_list.append(pat.group(1))

if len(sys.argv) != 2:
        print "Usage: %s <country acronym>\nExamples:\n\t%s pt\n\t%s fr\n\t%s us" % (eval("sys.argv[0]," * 4))
        sys.exit(1)

try:
        rhost = httplib.HTTPConnection("www.nirsoft.net")
        rhost.request("GET", "/countryip/%s.html" % sys.argv[1])
        pbody = rhost.getresponse().read()
        rhost.close()
except:
        print "Ops..."
        sys.exit(1)

ORHTMLParser().feed(pbody)

paired_block_list = map(lambda start, end: (start, end), raw_block_list[0::2], raw_block_list[1::2])

for pair in paired_block_list:
        print "from", pair[0], "to", pair[1]

Saudações

Maio 30, 2012

Arvorezinha 2.0 - No explicit loops nor conditions, C99 & POSIX Compliant

Arquivado em: arvorezinha, coding, serious-business, useless — thread @ 12:52

Cá vai uma arvorezinha 2.0 totalmente inútil em C, sem loops nem condições (pelo menos, explicitamente)… um verdadeiro apedrejamento aos rins dos recursos. No entanto, está compliant com C99 e POSIX. Não está à prova de numeros demasiado grandes para o seu tamanho… receberão um exit status 1 caso se exceda o temporary size max e uma arvorezinha bem destruida.

Deixando-me de lengalengas… aqui vai:

-- EDIT: Nova versão do code. Não valia a pena criar outro post com mais do mesmo, portanto editei aqui mesmo.

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

#define TEMPORARY_SIZE_MAX 128

int n, l, magic = 0;

void bye(void);
void bazinga(void);
void draw_bottom(void);
void draw_top(void);

void (*magic_matrix[2][2]) (void) = { { &bazinga, &draw_top }, { &bye, &draw_bottom } };


void sigsegv_syntax(int s) {
    printf("Invalid syntax.\n");
    exit(EXIT_FAILURE);
}

void sigsegv_toolarge(int s) {
    printf("Value too large.\n");
    exit(EXIT_FAILURE);
}

void bye(void) {
    exit(EXIT_SUCCESS);
}

void bazinga(void) {
    n = l;
    magic++;

    draw_bottom();
}

void draw_bottom(void) {
    printf("\x1b[%dC\x1b[%dD", (l / 2) * (n & 1) + 1, !(n & 1));
    fwrite(memset((char [TEMPORARY_SIZE_MAX]) { }, 0x23, TEMPORARY_SIZE_MAX), n & 1, l - !(l & 1), stdout);
    fwrite("\n", n & 1, 1, stdout);

    magic_matrix[magic][!!--n]();
}

void draw_top(void) {
    printf("\x1b[%d%c", n - 1, 0x43 + !(n - 1));
    fwrite(memset((char [TEMPORARY_SIZE_MAX]) { }, 0x2A, TEMPORARY_SIZE_MAX), 1, (((l - n) + 1) * 2) - 1, stdout);
    putchar('\n');

    magic_matrix[magic][!!--n]();
}


int main(int argc, char *argv[]) {
    signal(SIGSEGV, &sigsegv_syntax);

    n = l = atoi(argv[1]);

    signal(SIGSEGV, &sigsegv_toolarge);

    draw_top();

    return EXIT_SUCCESS;
}

PoC:

# gcc -Wall --std=c99 -o arv2 arv2.c
# ./arv2 15
              *
             ***
            *****
           *******
          *********
         ***********
        *************
       ***************
      *****************
     *******************
    *********************
   ***********************
  *************************
 ***************************
*****************************
       ###############
       ###############
       ###############
       ###############
       ###############
       ###############
       ###############
       ###############
# echo $?
0
#

Maio 28, 2012

Arvorezinha 2.0 - C++11 Templates

Arquivado em: arvorezinha, coding, serious-business, useless — dcoder @ 17:02

Ora viva!

Desde a minha última submissão, tem havido vasto progresso no estado da arte da Arvorezinha. Foi lançado um novo standard, e tem havido um renovado interesse em criar arvorezinhas cada vez mais obscuras e intricadas.

Isto traz-nos a este post. Um dos problemas fundamentais com as arvorezinhas anteriores em templates de C++ era que cada caracter era impresso de cada vez. Era muito mais interessante se pudéssemos gerar a string completa da arvorezinha durante a compilação, após o qual imprimir seria apenas uma questão de enviar a string para a função adequada (printf, cout, etc). Uma das novidades no novo standard de C++, oficializado o ano passado, são os variadic templates. Estes são uma versão em templates das funções com número de argumentos variável, como já existiam em C(++) e no pré-processador de C, que nos permite “construir” uma string caracter a caracter, e despejá-la numa initializer list quando acabamos.

Para simplificar a apresentação, desacoplei a lógica da arvorezinha da lógica que constrói a string, para ser mais fácil compreender a implementação. Também incluí uma versão não variádica opcional, caso não estejam satisfeitos.

#include <cstdio>

struct NullType {};
 
template<size_t N>
struct Arvorezinha2
{
    static const size_t NC = 2*N * (N + N/2);

    template<bool B, size_t L, size_t C> struct Pedaco;

    template<size_t L, size_t C>
    struct Pedaco<true, L, C> // Arvore
    {

        template<bool B, typename D>
        struct Ramo
        {
            static const char value = ' ';
        };              

        template<typename D>
        struct Ramo<true, D>
        {
            static const char value = '*';
        };

        static const size_t len = N*2 - 1;
        static const size_t beg = N-(L+1);
        static const size_t end = 2*(L+1)-1;
        static const char value = Ramo<C >= beg && C < beg + end, NullType>::value;
    };

    template<size_t L, size_t C>
    struct Pedaco<false, L, C> // Tronco
    {
        template<bool B, typename D>
        struct Lenha
        {
            static const char value = ' ';
        };

        template<typename D>
        struct Lenha<true,D>
        {
            static const char value = '#';
        };

        static const size_t len = N*2 - 1;
        static const size_t beg = len/4 - N%2 + 1;
        static const size_t end = len/2 - !(N%2);
        static const char value = Lenha<C >= beg && C <= beg + end, NullType>::value;
    };

    template<size_t L>
    struct Pedaco<true, L, 2*N-1>
    {
        static const char value = '\n';
    };

    template<size_t L>
    struct Pedaco<false, L, 2*N-1>
    {
        static const char value = '\n';
    };


    template<size_t X>
    struct Arvorezinha
    {
        static const size_t L = X / (2*N);
        static const size_t C = X % (2*N);
        static const char value = Pedaco<L < N, L, C>::value;
    };

    template<size_t I>
    struct AT
    {
        static const char value = Arvorezinha<I>::value;
    };    
};

template<template<size_t> class T, size_t N, bool V/*ariadic*/ = true>
struct Desenhar
{
    template<char... Str>
    static inline const char (&str())[sizeof...(Str)+1]
    {
        static const char value[sizeof...(Str)+1] = {Str..., 0};
        return value;
    }

    template<size_t I, typename D, char...Str>
    struct StringBuilder
    {
        static inline const char *toStr()
        {
            return StringBuilder<I+1, D, Str..., T<N>::template AT<I>::value>::toStr();
        }
    };

    template<typename D, char...Str>
    struct StringBuilder<T<N>::NC, D, Str...>
    {
        static inline const char *toStr()
        {
            return str<Str...>();
        }
    };

    static inline const char *toString()
    {
        return StringBuilder<0,NullType>::toStr();
    }

    static inline void desenhar()
    {
        puts(toString());
    }

};

template<template<size_t> class T, size_t N>
struct Desenhar<T, N, false>
{
    template<size_t i, typename D/*ummy*/>
    struct Rec
    {
        static inline void desenhar()
        {
            Rec<i-1,D>::desenhar();
            putchar(T<N>::template AT<i>::value);
        }
    };
 
    template<typename D>
    struct Rec<0,D>
    {
        static inline void desenhar()
        {
            putchar(T<N>::template AT<0>::value);
        }
    };
 
    static inline void desenhar()
    {
        Rec<T<N>::NC-1, NullType>::desenhar();
    }
};

int main(int argc, char **argv)
{
    Desenhar<Arvorezinha2, 5/*, true*/>::desenhar();
    return 0;
}

O resultado da compilação é essencialmente óptimo: o programa resume-me a carregar o endereço de uma string, e chamar a função puts:

0000000000400430 <main>:
  400430:	48 83 ec 08          	sub    $0x8,%rsp
  400434:	bf 40 06 40 00       	mov    $0x400640,%edi
  400439:	e8 d2 ff ff ff       	callq  400410 <puts@plt>
  40043e:	31 c0                	xor    %eax,%eax
  400440:	48 83 c4 08          	add    $0x8,%rsp
  400444:	c3                   	retq   
  400445:	90                   	nop
  400446:	90                   	nop
  400447:	90                   	nop

Bem haja!

Maio 14, 2012

Arvorezinha 2.0 Python

Arquivado em: arvorezinha, coding, serious-business, useless — thread @ 02:00

Ora cá vai mais uma Arvorezinha 2.0 em Python:

#!/usr/bin/python
import sys

print ("".join(map(lambda top: ((' ' * ((int(sys.argv[1])) - top / 2 - 1)) + ('*' * top)) + "\n", range(1, int(sys.argv[1]) * 2 + 1, 2))) + ((' ' * (int(sys.argv[1]) / 2)) + ('#' * (int(sys.argv[1]) - ((int(sys.argv[1]) + 1) % 2)) + "\n")) * (int(sys.argv[1]) / 2)).strip('\n')

Janeiro 4, 2012

Arvorezinha em perl

Arquivado em: arvorezinha, serious-business, useless — korn @ 16:54

Como a ultima arvorezinha era muito grande, vai aqui uma versão reduzida da v2!

#!/usr/bin/perl
$i=$ARGV[0];map{$a.=" "x($i-$_-1)."*"x($_*2+1)."\n";$b.=" "x($i/2)."#"x($i%2?$i:$i-1)."\n"if($i-$_+1)%2}(0..$i-1);print$a.$b;

Dezembro 26, 2011

Como não ganhar um iPad 2

Arquivado em: coding, cracking, drama, fail, useless — falso @ 03:09

Boas noites,

Venho hoje aqui blogar a minha tristeza ao saber que a password do concurso para ganhar um iPad 2 no Pplware é alta string manhosa.

Vou começar então a falar da minha jornada para tentar ganhar isto…

Comecei por andar a procurar qual era o software que usava a extensão “xcon”, um amigo meu descobriu entretanto que era o Conceal, um software todo manhoso em .NET.
Experimentei umas passwords básicas no programa só para ver se advinhava antes de fazer alguma coisa mais complexa, mas o programa era tão manhoso que se usasse uma password invalida ele crashava, então desisti dessa aproximação.

Falei com um amigo meu todo cromo da criptografia e ele automagicamente disse-me que aquilo eram blocos de TripleDES CBC.

Caso os senhores do Pplware não saibam, bruteforcar TripleDes não é assim pêra doce, citando a Wikipedia (está sempre correcta :-P):

“Deep Crack was designed by Cryptography Research, Inc., Advanced Wireless Technologies and the EFF. …  Advanced Wireless Technologies built 1856 custom ASICDES chips housed on 29 circuit boards of 64 chips each. The boards were then fitted in six cabinets and mounted in a Sun-4/470 chassis. … The entire machine was capable of testing over 90 billion keys per second. It would take about 9 days to test every possible key at that rate. On average, the correct key would be found in half that time.

Entretanto, eu sem sabendo que era alta string manhosa, e pensando que a password poderia ser o titulo de algum dos produtos entre 50 e 100€, fiz um scriptzinho que ia la parsar o site do OfficeLan e sacar de la os títulos todos (faz uso do phpQuery):

<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
</head>
<?php

require('phpQuery.php');

// batota, tem o total hardcoded
for($start = 0; $start <= 120; $start = $start + 20) {
	$url = 'http://shop.officelan.pt/pesquisa.html?start='.$start;
	$fields = array(
		'yagendoo_price_min'=>urlencode('50'),
		'yagendoo_price_max'=>urlencode('100'),
		'option'=>urlencode('com_yagendoo_vmsearch'),
	);
	$fields_string = "";
	foreach($fields as $key=>$value) { $fields_string .= $key.'='.$value.'&'; }
	rtrim($fields_string,'&');

	$ch = curl_init();
	curl_setopt($ch,CURLOPT_URL,$url);
	curl_setopt($ch,CURLOPT_POST,count($fields));
	curl_setopt($ch,CURLOPT_POSTFIELDS,$fields_string);
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

	$result = curl_exec($ch);

	curl_close($ch);

	$doc = phpQuery::newDocument($result);
	phpQuery::selectDocument($doc);

	foreach(pq('span.yagendoo_searchresult_title a') as $product) {
			echo $product->nodeValue;
			echo '<br/>';
	}
}

E com o resultado fui experimentar o seguinte:

<?php

$produtos = array(
  'MikroTik RouterBOARD 411U (Level 4) - RB411U - RB/411U',
  'MikroTik RouterBOARD 411AR (Level 4) - RB411AR - RB/411AR',
  ...
  'ANTENA INTERLINE SECTORIAL 12dBi/2.4GHz Mimo',
  'ANTENA INTERLINE SECTORIAL 12dBi/2.4GHz',
  'Presente', 'Presente_Natal', 'Presente_Natal.zip',
  'OfficeLan', 'pplware', 'natal',
);

$string = file_get_contents('nome_produto_offiLan.xcon');
foreach($produtos as $key) {
	$output = mcrypt_decrypt( MCRYPT_3DES , $key , $string , 'cbc');
	echo '<h4>'.$key.'</h4>';
	echo '<pre>'.$output.'</pre>';
}

Mas sem grandes resultados… Então foi que me disseram que o TripleDES CBC alem de uma key na cifra usa também outra variável, que é o IV (Initialization vector), que pelo que entendi, são dados usados para “inicializar” a cifra.
Então o tal programa tinha de usar algum algoritmo para “gerar” um IV a partir da nossa password ou então usava algum valor fixo, decidi tentar descobrir.

Andei a procura de técnicas sobre reversing a cenas .NET e achei alta programinha hacker, .NET Reflector.
Neste belo software, abre-se um executável .NET e ele escreve mais ou menos o codigo desse executável em belíssimo código C#, só os nomes de algumas funções e variáveis é que se perdem…

Então abri o executável do Conceal, e andei la a vasculhar, e no Form2 achei lá uma função chamada tdes_decrypt() e vi que era a função desejada, mas que a key e o IV eram calculados noutro lado, então com outra feature bonita deste programa, fiz Analyze nessa função e vi que era chamada pela func2(), e BINGO nessa achei o algoritmo que era usado para a key e o IV.

Decidi então criar um novo projecto C# no Visual Studio, onde iria utilizar o código do programa gerado pelo Reflector, mas podia-lhe alimentar um array gigante de passwords (a lista de produtos anterior). E com poucas dificuldades consegui mete-lo a funcionar, mas rapidamente vi que nenhuma das passwords que estava tentar usar era a correcta.
Sem saber mais o que tentar, rapidamente desisti…

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace unconceal
{
    class Program
    {
        public static void tdes_decrypt(String inputfile, String outputfile, byte[] key, byte[] IV)
        {
            long bytecount = 0L;
            long fread_len = 0L;
            int numbytes = 0;
            byte[] mybuffer = new byte[0xf4241]; 
            TripleDESCryptoServiceProvider tdesProvider;
            CryptoStream cryptStream;

            FileStream freader = new FileStream(inputfile, FileMode.Open, FileAccess.ReadWrite);
            FileStream fwriter = new FileStream(outputfile, FileMode.OpenOrCreate, FileAccess.Write);

            fread_len = freader.Length;

            tdesProvider = new TripleDESCryptoServiceProvider();
            tdesProvider.Key = key;
            tdesProvider.IV = IV;
            tdesProvider.Padding = PaddingMode.Zeros;

            cryptStream = new CryptoStream(fwriter, tdesProvider.CreateDecryptor(), CryptoStreamMode.Write);
            int num = 0;
            num = inputfile.Length - 1;

            while (bytecount < fread_len)
            {
                numbytes = freader.Read(mybuffer, 0, 0xf4240);
                cryptStream.Write(mybuffer, 0, numbytes);
                bytecount += numbytes;
            }

            while (bytecount % 8 != 0)
            {
                cryptStream.WriteByte(0);
                bytecount++;
            }

            freader.Close();
            cryptStream.Close();
        }

        static void Main(string[] args)
        {
            List<string> passwords = new List<string>(new string[]
	        {
                "MikroTik RouterBOARD 411U (Level 4) - RB411U - RB/411U",
                "MikroTik RouterBOARD 411AR (Level 4) - RB411AR - RB/411AR",
                ...
                "ANTENA INTERLINE SECTORIAL 12dBi/2.4GHz Mimo",
                "ANTENA INTERLINE SECTORIAL 12dBi/2.4GHz",
                "Presente",
                "Presente_Natal",
                "Presente_Natal.zip",
                "OfficeLan",
                "pplware",
                "natal",
                "Natal",
                "iPad2",
                "Natal 2011",
                "PPLWARE.COM",
                "EBA428ECA16691133FA946FED56AF824E8527BB6",
                "_F2Liz12!" // password correct, mas só agora :(
        	});

            int x = 0;
            foreach (String for_keyf1 in passwords)
            {
                String password = for_keyf1.ToString();

                byte[] bytes = new byte[0x2710];
                int charIndex = 0;
                int length = for_keyf1.Length;
                byte[] buffer2 = new byte[length + 1];
                int index = 0;
                int num4 = 0;
                int num7 = length - 1;
                for (index = 0; index <= num7; index++)
                {
                    num4 += 3;
                    buffer2[index] = (byte)(Convert.ToInt64(for_keyf1[index]) + (index + num4));
                    num4--;
                }
                new ASCIIEncoding().GetBytes(Encoding.ASCII.GetString(buffer2), charIndex, Encoding.ASCII.GetString(buffer2).Length, bytes, charIndex);
                byte[] buffer3 = new SHA1CryptoServiceProvider().ComputeHash(bytes);

                byte[] key = new byte[24];
                key[0] = buffer3[2];
                key[1] = buffer3[6];
                key[2] = buffer3[0x12];
                key[3] = buffer3[0x10];
                key[4] = buffer3[0x13];
                key[5] = buffer3[1];
                key[6] = buffer3[9];
                key[7] = buffer3[7];
                key[8] = buffer3[14];
                key[9] = buffer3[3];
                key[10] = buffer3[8];
                key[11] = buffer3[0x11];
                key[12] = buffer3[10];
                key[13] = buffer3[15];
                key[14] = buffer3[0];
                key[15] = buffer3[11];
                key[0x10] = buffer3[9];
                key[0x11] = buffer3[4];
                key[0x12] = buffer3[0x12];
                key[0x13] = buffer3[5];
                key[20] = buffer3[11];
                key[0x15] = buffer3[2];
                key[0x16] = buffer3[0x13];
                key[0x17] = buffer3[0];

                byte[] iv = new byte[8];
                iv[0] = buffer3[2];
                iv[1] = buffer3[6];
                iv[2] = buffer3[0x12];
                iv[3] = buffer3[0x10];
                iv[4] = buffer3[0x13];
                iv[5] = buffer3[1];
                iv[6] = buffer3[9];
                iv[7] = buffer3[7];

                tdes_decrypt(@"C:\Users\falso\Documents\Visual Studio 2010\Projects\unconceal\unconceal\nome_produto_offiLan.xcon",
                    @"C:\Users\falso\Documents\Visual Studio 2010\Projects\unconceal\unconceal\" + x.ToString() + ".txt",
                    key, iv);

                string text = System.IO.File.ReadAllText(@"C:\Users\falso\Documents\Visual Studio 2010\Projects\unconceal\unconceal\" + x.ToString() + ".txt");
                System.Console.WriteLine("String = {0}", text);
                x++;
            }
        }
    }
}

Hoje dia 26 de Dezembro, lembrei-me de ir ver qual era afinal a password do concurso, e foi então que descobri que era “_F2Liz12!”, adicionei essa string ao meu programinha em C# e não é que funcionou?

Download do projecto unconceal (belo nome :-P) para Visual Studio, para caso alguém esteja interessado em brincar mais com isto. Não esquecer os caminhos que estão hardcoded ao chamar a função tdes_decrypt().

Acho que para a próxima os senhores do Pplware deviam fazer concursos mais bem pensados, onde ganhe quem acha o resultado final, e não quem escolhe um produto à sorte que esteja no intervalo de preços dito inicialmente (dor de corno).

Um abraço e até à próxima!

Dezembro 22, 2011

Ano do Linux no Desktop

Arquivado em: useless — madinfo @ 15:33

Faltam apenas 10 dias!!!