Mais um blog inútil.

Hoje finalmente tive pachorra, e comecei a fazer um site que já andava a falar há bue de tempo, um site com expressões típicas portuguesas. Utilizei uma framework open sores chamada codeigniter para fazer isto e ate agora parece me ser bacano. Não esperem nada de especial ainda, mas futuramente vai ser o site mais visitado do mundo ate ser comprado pelo google!

http://expressoes.blol.org/

Bom, estava eu aqui a divagar pela Interweb e pelo IRC, quando o bot IONews do #linuxhelp me dá uma noticia maravilhosa, uma distribuição nova de BSD: MidnightBSD.

Ora o MeiaNoite BSD deve ser algo de extraordinário pensei eu, meia noite e BSD na mesma palavra só pode ser algo admirável no mínimo. Decidi abrir o website do meianoiteBSD pensando que me ia surpreender ainda mais, e claro está, fiquei boqueaberto pois o slogan é “BSD for everyone”. Boa! pensei eu, agora também há um BSD para toda a gente usar no desktop, já estava como imaginam a salivar mais que o cão do Pavlov.

Bom,o site está bem desenhado e pensei eu: “mas será que isto é mesmo virado para o desktop?”. Como calculam as minhas retincências nesta matéria são altas e decidi abrir os screenshots para ver como se parecia. “Algum KDE4 com o compiz e um theme escuro” ..pensei eu.

Bom, não poderia estar mais enganado e aqui teem o meianoiteBSD em todo o seu explandor no desktop:

[imagem perdida]
MeiaNoiteBSD

Everyone needs cryptographically strong pseudo random numbers in this day and age. From card games to your Paypal HTTPS session, it has become an essential part of secure systems. Now, as a user it’s hard to generate randomness; we all know how many systems are seeded with time(NULL) or the like. That’s why most operating systems have mechanisms to provide randomness to the user. In Unix systems, this is usually done through /dev/?random; on Windows, through the function CryptGenRandom.

However, CryptGenRandom requires a handle to a CSP (acquired by calling CryptAcquireContext). If all we want is random bytes, this no good; a full-fledged CSP takes too many resources (and time to load) for the task at hand. So an alternative is to use the lower level function RtlGenRandom, which doesn’t require a CSP context. This name is an actual alias for the function ‘SystemFunction036’ in advapi32.dll. MSDN reports: “This function has no associated import library. This function is available as a resource named SystemFunction036 in Advapi32.dll. You must use the LoadLibrary and GetProcAddress functions to dynamically link to Advapi32.dll”. But what if we don’t want the pain of loading and unloading libraries at runtime? I’ll show you how to make the required import library to avoid this.

The main problem you will encounter  is that RtlGenRandom’s calling convention is __stdcall, whereas its actual name in advapi32.dll does not reflect that (__stdcall functions have the number of bytes passed as parameters in the stack appended in the function name. In this case, it expects SystemFunction036 to be called SystemFunction036@8). Using the LIB utility doesn’t help, even when using aliases: it always expects the appended number of bytes to be there. So first idea is to use function ordinals. Running DUMPBIN /EXPORTS on advapi32.dll shows us:

621  26C 00008292 SystemFunction036 = _SystemFunction036@8

So now we know the ordinal of our function: 621. With this in mind, we can now use LIB to create a .lib to link against our application. First, create a .def file with the following lines:

LIBRARY advapi32.dll

EXPORTS

SystemFunction036@8 @ 621

Now run:

lib /DEF:RtlGenRandom.def /OUT:RtlGenRandom.lib /MACHINE:X86

Now you can just link the resulting .lib with your application to have the desired result.

However, this is not a good solution. Ordinals are by no means fixed (unless you’re dealing with Winsock2 or MFC dynamic libraries) and you have no guarantee they’ll be the same across Windows versions. So here’s another way to do it. First, create a C source file and declare an empty function equal to RtlGenRandom:

#include <windows.h>
#define RtlGenRandom SystemFunction036
#define DLLEXPORT 	__declspec(dllexport)
DLLEXPORT BOOLEAN WINAPI RtlGenRandom(PVOID in, ULONG len) {}

Now create a .def like the following:

LIBRARY advapi32.dll
EXPORTS
SystemFunction036

Now we compile the source and feed the DEF to the linker:

cl dummy.c dummy.def

The actual binary output of this compilation is irrelevant; what we want is the resulting dummy.lib. You can now link against this import library and it will link to the real advapi32.dll, thus giving us what we want. I used the following test source to try it out:

#include <stdio.h>
#include <windows.h>

#define RtlGenRandom                    SystemFunction036
BOOLEAN WINAPI RtlGenRandom(PVOID, ULONG);

int main(int argc, char **argv)
{
    BYTE blah[20];
    DWORD i;

    RtlGenRandom(blah, 20);

    for(i=0; i < 20; i++)
        printf("%02X ", blah[i]);

    return 0;
}

Compile with:

cl /O2 /MT test.c dummy.lib

Problem solved. Try it out.

PS: Someone’s bound to comment “oh but Windows’ PRNG is flawed, there was a paper on it some time ago”. That’s correct. However, both attacks (forward and backward security compromised) assume you already have knowledge of the whole state of the PRNG (i.e. you’ve owned the box) and that you’re running a Windows previous to XP SP3, which fixed the issue.

epa sintam só a capa do cd! e do DVD. E DAQUELE BONGO QUE SE CALHAR VOU COMPRAR PARA FUMAR UMA ERVADA COM O OB

Pois é, meus amigos.

Há alguns dias deparei-me com isto: http://forum.kaspersky.com/index.php?showtopic=71652

Aparentemente, os bons senhores da Kaspersky acham boa ideia factorizar um módulo de 1024 bits para de alguma forma combater o ransomware gpcode. Boa sorte com os vossos 100 anos de factorização.

E que tal obterem o utilitário que faz a decriptação (paguem ao gajo se for preciso, nós também temos de vos pagar), e extrairem de lá a chave? Sim, já que não percebem de criptografia, ao menos de reverse engineering devem ter umas luzes.

Enfim.

Olá amigos.

Hoje eu e o Pedro Monteiro não fomos para a aulinha e por isso fomos comer para o bar da escola.
Comemos alta sandezinha de queijo com um leitinho fresco… mesmo bom!

Aqui está a prova:

E tive que vir para aqui blolar sobre isto.

PS: Já tinha saudades. Beijinhos para o luminoso (adoro falar com ele sobre o gaytoo)

O FiSH é uma valente seca para se compilar - é um facto. Em particular quando se fala em compilá-lo num SO opensores numa arquitectura não x86. A biblioteca MIRACL que aquilo usa é essencialmente o problema aqui. Portanto a escolha lógica é acabar com esta biblioteca e usar uma ligeiramente mais decente.

Agora, a biblioteca em si não é nada má. Para fins criptográficos provê montes de coisas úteis que seriam feitas à mão de outro modo – números aleatórios seguros, curvas elípticas (e construção de boas curvas - poucas bibliotecas são minimamente úteis neste aspecto), além de possuir hashing (SHA-2) e encriptação (AES) incorporados. No entanto, o processo de compilação é absolutamente deixado ao acaso e a documentação é como deixar o Bear Grylls no deserto sem um hotel por perto.

Obviamente eu não fui o primeiro a ter esta ideia. Nos próprios fórums já foi sugerido múltiplas vezes esta mudança, e aparentemente alguém já a fez. Mas vamos lá olhar para este patch com olhos de ver:

int DH1080_gen(char *priv_key, char *pub_key)
{
…..

+ mpz_t mpz_privkey, mpz_prime, mpz_pubkey, mpz_base;
+ gmp_randstate_t randstate;
// #\#\#\#\#\* RNG START #*#*#*#*#*
time((time_t *)&seed);
+ gmp_randinit_default(randstate);
+ gmp_randseed_ui(randstate, seed);
+ mpz_urandomb(mpz_privkey, randstate, 1080);
+ gmp_randclear(randstate);
seed=0;
// #\#\#\#\#\* RNG END #*#*#*#*#*
….

}

Aparentemente o nosso génio, além de utilizar a função errada (deveria ser mpz_urandomm) para gerar números entre 0 e mpz_prime exclusive (mpz_prime sendo o primo que define o grupo onde estamos a trabalhar e por sua vez define a dificuldade do problema no caso de uma implementação em condições), não verifica se a chave pública criada é 0 ou 1 (o que arruinaria ligeiramente a segurança nesse caso estupidamente remoto). Mas aqui a maior falha é utilizar a data do sistema como seed para a chave privada. Sim, todas as chaves possíveis criadas com este patch estão dependentes de um valor de 32 bits (que na prática pode ser reduzido muito mais – é um timestamp). Parece-me que alguém não faz ideia do que está a fazer (aparentemente uma situação generalizada na indústria da segurança, diga-se de passagem).

Mas enfim, não se pode apenas criticar. Com o intuito de parecer ligeiramente menos hipócrita, coloco aqui a minha própria modificação que utiliza um método ligeiramente mais seguro para a geração de chaves (no código original, era criado e seedado um novo csprng por cada troca – qual a necessidade?). Utilizo a cifra ISAAC para a geração de números aleatórios (não se pode ser muito mais judeu que isto, eh?), e esta é alimentada com 256 bytes do /dev/urandom (caso queiram portar para Windows podem facilmente utilizar a RtlGenRandom) misturados com a SHA-256 do blow.ini e do irssi.conf. É então gerado um número e certificamo-nos que este se encontra no intervalo [2; prime1080-1].

Para a aritmética uso a GMP. Alterei apenas o plugin para irssi, mas quaisquer alterações são facilmente movidas para as outras versões. Deixo o licenciamento para quem não tem mais nada em que pensar.

Download

Nota: Se estiverem a usar Ubuntu e não conseguirem compilar, a culpa não é minha.

Nota2: Se são verdadeiramente paranóicos, estão a utilizar a ferramenta errada. A troca de chaves como é implementada no FiSH (puro Diffie-Hellman) é vulnerável a ataques man-in-the-middle, uma vez que não existe qualquer autenticação; se querem algo minimamente seguro, talvez o SILC não seja um mau começo.

Aparentemente saiu uma nova versão do xcrap, 2.8.7a. Eu reparei nisto e lembrei-me que houve um post do falso ha uns tempos que falava de como crackar opensores. Infelizmente, não tenho muito tempo por isso vou ser sucinto.

O leitor assíduo facilmente vai descompactar o executável (é uma versão antiga do UPX) e encontrar a função de interesse (sub_4018CD).

Aqui encontramos o algoritmo de verificação, que consiste essencialmente em:

Hash = SHA-1(Linha3|Linha4|Linha4)

E = 0x25F86508483EFD

N = 0xB5BA27D856CCBE6B61CFE96A387D8E265A65897510AE91212634A7397432D1B2407604CAFA9DC77EF29A87B86D938748E0C4921D46C3AC4BCE7E00EECDFCF782DBD0D44C46C9057724CCF7DEDF36924E4683721FF55EDC570C4C71927887D67C1B1488A33E0B3F64160701B2390C3B3F278490B22DE9906A65B9DFBDF4E838870EFD5851DC0B2C94E444E0B1D2DAAA5C6060D3976E170BB8692111E26D178871008AE42EE250A856D2354102B57F560420AC9F89D004AF761341764FBEDD194A27AF6F34B9C0E3A48013734C6CBD3C216CFAD9B1F3DFDB76FE8519C78E3E95F3C4B39006111DE983C88D72CD4613D4CB852D36244D7B8D4AB15C740415382735

GoodSignature = 00 01 FF FF … (tem de ter 256 bytes (2048 bit) … FF FF 00 30 21 30 09 06 05 2B 0E 03 02 1A 05 00 04 14 | Hash

if (Linha2 ^ E (mod N) == GoodSignature) return GOOD else return BAD

OK, então temos basicamente uma assinatura digital baseada em RSA com 2048 bits. Não existem exploits óbvias (padding, expoente baixo, …) que se possam aproveitar; portanto, para fazer um keygen temos de alterar a chave pública. Escolham uma e substituam no sítio apropriado (public_key_n). Para gerar uma chave válida, temos então:

void generate_key(void)

{

char LInha1[] = “# Designed and implemented exclusively for the lulz”;

char Linha2[1024];

char Linha3[] = “Some Jew”;

char Linha4[] = “Crap”;

char Linha5[] = “More crap”;

HCRYPTPROV hProv;

HCRYPTHASH hHash;

unsigned char appendage[] = {00, 30, 21, 30, 09, 06, 05, 2B, 0E, 03, 02, 1A, 05, 00, 04, 14};

unsigned char good_signature[256];

unsigned char sha[32];

unsigned long tmp = 20;

mpz_t n, d, c;

memset(Linha2, 0, sizeof(Linha2)*sizeof(Linha2[0]));

CryptAcquireContext(&hProv, 0, 0, 1, 0xF0000000);
CryptCreateHash(hProv, 0x00008004, 0, 0, &hHash);
CryptHashData(hHash, Line3, strlen(Line3), 0);
CryptHashData(hHash, Line4, strlen(Line4), 0);
CryptHashData(hHash, Line5, strlen(Line5), 0);
CryptGetHashParam(hHash, 2, sha, &tmp, 0);
CryptDestroyHash(hHash);
CryptReleaseContext(hProv, 0);

memset(good_signature, 0xFF, 256);

memcpy(good_signature+220, appendage, sizeof(appendage));

memcpy(good_signature+236, sha, 20);

good_signature[0] = 0;

good_signature[1] = 1;

mpz_init_set_str(n, “9AFF449090074D691910719D0B384FDA86FAB987938E74CB6E6A91BE6086A8E11BDBD2EF7C1F3761EEBC3AB171F2FB9A79BD8A3CFBAD54A707F39FB8E804A0F4874447BE66550E9D444C496D251FF2402DC8DBAD7352124633F5CAF43A3971362B4466F28AAB1C2A1E81F36B8EE5E6284DD9645E500083B0B9102D559A57A52F0E831F7B39B630DC9B479E3914F34F33363A2075F372E650B94D230528A998D1613C097D78C1C66AE647E0DCF9590E3CA012C3A26614F851AE520163699044F6E8F71B8EDA7091DFDB4745FE27A806EF56E6B7B7175B7859B1725ACF6A03CC941DFED8773AA02DF350C3C0479744411B7F1CD625F5BF4F76E38DD42AC4901A89”, 16);

mpz_init_set_str(d, “36C70BF3DDBD70026346284E9E40E0B1637DD2FF8506F959772CBCEE7F2613A8697D8B822C6849753541DFAECA891A50C0F515E42F1BC8DFF2F48452BA27D29602E572DC9676512F1631AEF655C8F37C03C9E9E5E532CABE4ABD0E0495FA1556AC484D2F5F6E8AF08F934C80CC8D0369215FA2E5F73C0648509867BE61B766C716D84934F76699FAD81EC04E78E88CCC592D59B183361F35B2F3A0F2FEDC17F94F73831111984E5AB2AFCCC019090E4A48AB6CFE249066EFA6D02A4A9EA8369E60EF45A2CC921AE66C52CA1D273EB0355BAC9FD7598258FF94ED311100E732D22224B3744C3ABBB6BA4995781B8427D2BBF605488AC20E19483C10894283506D”, 16);

mpz_init(c);

mpz_powm(c, c, d, n);

printf("%s\n", Linha1);

gmp_printf("%Zd\n", c);

printf("%s\n", Linha3);

printf("%s\n", Linha4);

printf("%s\n", Linha5);

mpz_clear(n);

mpz_clear(d);

mpz_clear(c);

}

Disclaimer: este código foi feito de cabeça e nem sequer o tentei compilar. Se não funcionar, DESCUBRAM porquê!

Note-se que o autor implementou duas verificações para prevenir a alteração do executável (e assim também, da chave).

Primeira:

UPX0:004081EE loc_4081EE: ; CODE XREF: sub_4081BA+45j
UPX0:004081EE movzx edi, ds:public_key_n[ecx]
UPX0:004081F5 add edi, edx
UPX0:004081F7 shl edi, 1
UPX0:004081F9 inc ecx
UPX0:004081FA cmp ecx, 40h
UPX0:004081FD mov edx, edi
UPX0:004081FF jb short loc_4081EE
UPX0:00408201 cmp edx, 0B3A690A6h
UPX0:00408207 pop edi
UPX0:00408208 jz short loc_40822B

Segunda:

UPX0:00425A7A loc_425A7A: ; CODE XREF: sub_425A14+74j
UPX0:00425A7A movzx edx, byte ptr [eax]
UPX0:00425A7D imul ecx, 1Fh
UPX0:00425A80 add ecx, edx
UPX0:00425A82 dec eax
UPX0:00425A83 cmp eax, offset sub_401000
UPX0:00425A88 jnz short loc_425A7A
UPX0:00425A8A cmp ecx, 1D9AB667h
UPX0:00425A90 jz short locret_425A98

Certifiquem-se que corrigem isto quando alterarem o executável.

Já agora, a IDB comentada.

Um bem haja para todos.

Ois, amiguinhos. Tenho andado um pouco afastado desta rambóia por motivos sérios e profissionais, embora volta e meia faça um ou outro comment a um ou outro post. Sim, confirmo, a vida de pseudo-trabalhador / pseudo-estudante é, de facto, desgastante aborrecida, por vezes. Hoje deparei-me com um drama aqui no trabalhinho que até foi fácil resolver após uns minutinhos a pensar e a pesquisar no gugal. Na minha aplicação existe o try / catch habitual para handlar as exceptions. Existe também um finally para fazer qualquer coisa nomatter what. No entanto, e como estou a correr a aplicação na consola, caso faça um CTRL+C , o troçozinho de código que consta no finally não é executado, o que é uma maçada…Então pensei: “Ora o que eu queria mesmo…era uma forma de handlar este signal….em Java!!” . Em C isto seria coisa simples, mas nunca me tinha deparado com este drama em Java, apesar de a solução ser igualmente simples. Aqui vai a solução e espero que possa ajudar alguém (e também poupar alguma pesquisa):

public class AMinhaClass
{
      public static void main( String[] args )
      {
         Runtime.getRuntime().addShutdownHook( new Thread() {
                 public void run()
                 {
                     System.out.println( "Handler code goes here..." );
                 }
             }
         );
      }
 }

Ahmm…ok, aquilo deveria estar dentro de um ciclo ou qualquer coisa que justifique um handler, mas não me apetece estar a reeditar o post porque não me estou a dar bem com as formatações e o camandro e tenho de voltar para o trabalho. Adeus.

(capturado pela webcam da torre da PT em Ponta Delgada)

REFRÃO:
Mãe querida, mãe querida
O melhor que a gente tem
Não há outro amor na vida
Igual ao amor de mãe

Feliz de quem possa dizer
Que tem ainda quem lhe deu o ser
Feliz de quem possa contar
Com o seu regaço pra se aconchegar

Graças a Deus, que tenho ainda
Carinhos teus minha mãe querida
O teu consolo, compreensão
Tuas palavras cheias de razão

REFRÃO

Dia da mãe devia ser
Todos os dias sem ninguém esquecer
Santa mãezinha, nossa alegria
Abençoado o teu nome Maria
Nunca na vida por coisa alguma
Eu vou esquecer que mãe há só uma
Feliz de quem possa dizer
Que ainda tem quem o viu nascer

REFRÃO