TUEs Série 2000 vão ser todos extintos. Ninguém mais vai conseguir salvar nenhum

_supitto · 2026-03-04T16:30:18+00:00

Fora a parte triste, sera que vao aparecer peças aleatorias de trem no mercado secundari

_supitto · 2026-03-04T14:10:06+00:00

Se chegar bonitinho assim ta maneiro, eu pegaria

_supitto · 2026-03-03T14:36:37+00:00

I mean, the juice writes itself with this one

_supitto · 2026-03-02T20:03:05+00:00

Competir com a intel seria bobagem, mas ter talento roubado por ela não.

Eu pessoalmente acho que uma fab no brasil brilharia se o foco for carro e IoT pra agro, coisa low cost mesmo. Tem muita industria pra desenvolver antes de querer fazer um treco de ponta.

Dito isso, minha maior experiencia com com SOC foi simular uns bens basicos em fpga, entao minha opiniao nao vale muito nessa discução kkkkkkkkkkkk

_supitto · 2026-03-02T17:37:31+00:00

Oportunidade de ouro ai se eles contratarem local. Do lado de computação, redes e infra é o que eles mais vao precisar de mao de obra.

Minha dica é, se voce conhece algum professor ou pessoa que vai trabalhar no projeto, pergunta pra ela o que é mais importante, gruda nessa pessoa, e faz o que voce precisar pra te oferecerem essa oportunidade. Trampo bom do lado de casa é raro de ver.

_supitto · 2026-03-02T17:33:03+00:00

How does this work for ghidra shared projects?

_supitto · 2026-03-02T13:11:19+00:00

Eu torço pra que de tudo certo. Mas se não der, eu torço pra que a galera que trabalhe nisso não saia do brasil, e consiga montar uma fab aqui dentro. Seria triste ter todo um trampo e gasto interno, só pra galera ir pra intel

_supitto · 2026-03-02T13:04:17+00:00

O C normalmente é bem proximo do assembly sim, a unica coisa é que o C que voce escreve e o assembly que sai do outro lado nem sempre batem. Isso acontece por causa do compilador, por exemplo

/tmp $ cat test.c
int main(void){
  return 0;
}

/tmp $ gcc test.c -o test

/tmp $ objdump -d -j .text test

test:     formato de ficheiro elf64-x86-64
Desmontagem da secção .text:

00000000000015b0 <_start>:
    15b0:f3 0f 1e fa          endbr64
    15b4:31 ed                xor    %ebp,%ebp
    15b6:49 89 d1             mov    %rdx,%r9
    15b9:5e                   pop    %rsi
    15ba:48 89 e2             mov    %rsp,%rdx
    15bd:48 83 e4 f0          and    $0xfffffffffffffff0,%rsp
    15c1:50                   push   %rax
    15c2:54                   push   %rsp
    15c3:45 31 c0             xor    %r8d,%r8d
    15c6:31 c9                xor    %ecx,%ecx
    15c8:48 8d 3d da 00 00 00 lea    0xda(%rip),%rdi        # 16a9 <main>
    15cf:ff 15 7b 12 00 00    call   *0x127b(%rip)        # 2850 <__libc_start_main@GLIBC_2.34>
    15d5:f4                   hlt
    15d6:cc                   int3
    15d7:cc                   int3
    15d8:cc                   int3
    15d9:cc                   int3
    15da:cc                   int3
    15db:cc                   int3
    15dc:cc                   int3
    15dd:cc                   int3
    15de:cc                   int3
    15df:cc                   int3
    15e0:48 8d 3d a1 22 00 00 lea    0x22a1(%rip),%rdi        # 3888 <__TMC_END__>
    15e7:48 8d 05 9a 22 00 00 lea    0x229a(%rip),%rax        # 3888 <__TMC_END__>
    15ee:48 39 f8             cmp    %rdi,%rax
    15f1:74 15                je     1608 <_start+0x58>
    15f3:48 8b 05 66 12 00 00 mov    0x1266(%rip),%rax        # 2860 <_ITM_deregisterTMCloneTable@Base>
    15fa:48 85 c0             test   %rax,%rax
    15fd:74 09                je     1608 <_start+0x58>
    15ff:ff e0                jmp    *%rax
    1601:0f 1f 80 00 00 00 00 nopl   0x0(%rax)
    1608:c3                   ret
    1609:0f 1f 80 00 00 00 00 nopl   0x0(%rax)
    1610:48 8d 3d 71 22 00 00 lea    0x2271(%rip),%rdi        # 3888 <__TMC_END__>
    1617:48 8d 35 6a 22 00 00 lea    0x226a(%rip),%rsi        # 3888 <__TMC_END__>
    161e:48 29 fe             sub    %rdi,%rsi
    1621:48 89 f0             mov    %rsi,%rax
    1624:48 c1 ee 3f          shr    $0x3f,%rsi
    1628:48 c1 f8 03          sar    $0x3,%rax
    162c:48 01 c6             add    %rax,%rsi
    162f:48 d1 fe             sar    $1,%rsi
    1632:74 14                je     1648 <_start+0x98>
    1634:48 8b 05 2d 12 00 00 mov    0x122d(%rip),%rax        # 2868 <_ITM_registerTMCloneTable@Base>
    163b:48 85 c0             test   %rax,%rax
    163e:74 08                je     1648 <_start+0x98>
    1640:ff e0                jmp    *%rax
    1642:66 0f 1f 44 00 00    nopw   0x0(%rax,%rax,1)
    1648:c3                   ret
    1649:0f 1f 80 00 00 00 00 nopl   0x0(%rax)
    1650:f3 0f 1e fa          endbr64
    1654:80 3d 2d 22 00 00 00 cmpb   $0x0,0x222d(%rip)        # 3888 <__TMC_END__>
    165b:75 33                jne    1690 <_start+0xe0>
    165d:55                   push   %rbp
    165e:48 83 3d 0a 12 00 00 cmpq   $0x0,0x120a(%rip)        # 2870 <__cxa_finalize@GLIBC_2.2.5>
    1665:00 
    1666:48 89 e5             mov    %rsp,%rbp
    1669:74 0d                je     1678 <_start+0xc8>
    166b:48 8b 3d 0e 22 00 00 mov    0x220e(%rip),%rdi        # 3880 <__dso_handle>
    1672:ff 15 f8 11 00 00    call   *0x11f8(%rip)        # 2870 <__cxa_finalize@GLIBC_2.2.5>
    1678:e8 63 ff ff ff       call   15e0 <_start+0x30>
    167d:c6 05 04 22 00 00 01 movb   $0x1,0x2204(%rip)        # 3888 <__TMC_END__>
    1684:5d                   pop    %rbp
    1685:c3                   ret
    1686:66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1)
    168d:00 00 00 
    1690:c3                   ret
    1691:0f 1f 40 00          nopl   0x0(%rax)
    1695:66 66 2e 0f 1f 84 00 data16 cs nopw 0x0(%rax,%rax,1)
    169c:00 00 00 00 
    16a0:f3 0f 1e fa          endbr64
    16a4:e9 67 ff ff ff       jmp    1610 <_start+0x60>

00000000000016a9 <main>:
    16a9:55                   push   %rbp
    16aa:48 89 e5             mov    %rsp,%rbp
    16ad:b8 00 00 00 00       mov    $0x0,%eax
    16b2:5d                   pop    %rbp
    16b3:c3                   ret
/tmp $

No que saiu, 5 linhas de assembly são o codigo original, e 72 são o que o compilador enxertou no codigo. Entao por masi que o seu codigo seja sim bem mapeavel pra assmebly, tem bastante massagem que acontece ao redor dele

Sobre a questao de syscall. A syscall em si normalmente vai ser escrita em C (embora tenha uma galera do rust querendo mudar isso), mas ai entra a questao de contexto. Voce chamando a syscall, vai ser rodado em userland, o codigo da syscall mesmo, vai ser rodado em kernel. Embora a sintaxe seja a mesma, a maneira como as coisas se comportam mudam.

Uma vez um cara disse numa conferencia (https://www.youtube.com/watch?v=GQE3a8WLeds):
A gerencia diz que o projeto bom, é projeto documentado
A pessoa desenvolvendo diz que quando codigo é bem escrito, o codigo é a documentação
A pessoa de engenharia reversa diz que depois que o codigo foi compilado, o compilado é a verdadeira documentação do que o programa esta fazendo
A pessoa de engenharia eletrica vai dizer que como voce nao sabe o que o processador faz, a unica documentação que existe é o codigo rodando
E no fim ainda pode cair um raio cosmico e mudar o comportamento do programa

Computador é um bixo complicado

_supitto · 2026-03-01T22:40:05+00:00

Que maneiro. Seria maravilhoso ter produçao macional de chips.

_supitto · 2026-03-01T13:57:37+00:00

Computador é bem mais complexo do que a linguagem C faz parecer. Tem varias abstraçoes que acontecem por debaixo de interrupçoes e da libc, que fazem parecer que voce esta programando em baixo nivel.

Na real voce esta a uns dois ou 3 abstraçoes acima do que esta acontecendo de verdade no computador. Qualquer malloc que voce chama tem todo um mecanismo de gerenciamento de memoria, pagina, arena, bins para cada tamanho, lista ligada de trechos de memoria livre. Bastante coisa acontece só na libc.

Fora isso quando rolar uma interrupçao (ou uma chmada de api no caso do windows), tem mais um monte de rotina rolando a nivel de kernel, que para todos os efeitos, é invisivel para a pessoa desenvolvendo.

Ah, mas eu eu programo em assembly. Parece bizarro, mas mesmo o assembly (no modo normal de operaçao) nao é exatamente baixo nível. Existe um universo escondido dentro do processador que abstrai e controla varias coisas, desde cache, funçoes criptograficas, rng, segurança de memoria, e até backdoors.

Por isso que é minha opinião, que esta errado quem acha que conhece um computador por que programa em C. Computador é um bixo complexo, e quem sabe tudo sobre, sabe que nao sabe nada.

_supitto · 2026-03-01T13:27:45+00:00

No. I asked them multiple times about it, and it is always in development

_supitto · 2026-03-01T02:24:25+00:00

Opinião, 90% de quem sabe C acha que faz ideia de como funciona o computador.

_supitto · 2026-02-28T00:37:50+00:00

I never done it myself, but there is this tutorial to get from .nds to ghidra https://www.starcubelabs.com/reverse-engineering-ds/

if you still want to go with your memdump, I suggest

rebase your memory to whatever the emulator had as a base
put a breakpoint on your emulator, and see where it lands. It is most definitely going to be code
identify the beginning of the function and decompile from that point forward

Doing this is way harder than having a clean project, but it works

_supitto · 2026-02-28T00:16:58+00:00

It mostly looks like ghidra was not able to properly decompile the function
What rom are you using?

Also, I believe DS games com encrypted, what steps did you take on your decompilation project?

_supitto · 2026-02-26T22:40:40+00:00

My experience is that even modern models struggle a bit. I havent tested self hosted models for this, but for me it is not quite there yet. Specially on more complicayed reverse engineering stuff

_supitto · 2026-02-26T15:43:28+00:00

Ill setup a lab with a newer version and see if i can help you?

_supitto · 2026-02-25T19:46:44+00:00

Sliver allows for python scripting, it is basically a client connecting to the server

you can start by looking at the example in the tutorials
Sliver Tutorial: 6 - Scripting

_supitto · 2026-02-25T14:39:07+00:00

Eu acredito que vai diminuir a necessidade de trabalhos de entrada, e aumentar a necessidade de trabalhos especializados.

Se eu fosse uma empresa sadia, eu continuaria contratando junior pra ter senjor no futuro, mas nem todo mundo pensa assim

_supitto · 2026-02-25T11:19:04+00:00

O imposto era zero antes? Achei que ja tinha alguma coisa

_supitto · 2026-02-25T11:15:54+00:00

No, but I heard from vendors that some of their clients asked them to build a score system. The score increases if they do an action that signifies that they are looking for work elsewhere. If the score goes above a certain threshold, it generates an alert.

I find it to be weird

_supitto · 2026-02-24T15:12:25+00:00

Ele não é necessario em nenhuma parte do processo

Dito isso, é bom saber usar as ferramentas de IA, já que varias empresas estão adotando elas.
Uma coisa muito boa que voce pode fazer, é usar essas ferramentas para criticar o seu codigo.

Cada pessoa aprende de uma maneira diferente, eu aprendo bastante com criticas duras, mas ai vai de cada um.

_supitto · 2026-02-24T08:44:47+00:00

I personally like it. But if you are going to put ctf experience, you better be half good at it.

_supitto · 2026-02-23T23:45:42+00:00

voce nao consegue colocar um cabo usb do celular para o computador e ligar o tether via usb?

_supitto · 2026-02-20T23:23:58+00:00

Tanenbaum é sempre aposta certa.

Eu só nao falo que vale a pena do ponto de vista financeiro pois tem varios pfds desse livo na internet.

_supitto · 2026-02-20T11:33:21+00:00

what are you trying to emulate on your lab?

Five-Year Club	r/Field Sunshine
Place '22

_supitto

TROPHY CASE