No momento, preciso usar o jwasm por alguns motivos desagradáveis que não vão mudar, então preciso fazer isso funcionar com o montador disponível, em vez do que eu preferiria.
Eu tenho:
bt [di], 0
Eu entendo:
Warning A4073: Size not specified, assuming: BYTE
Mas se eu tentar
bt byte ptr [di], 0
Eu entendo
Error A2049: Invalid instruction operands
Acho que o aviso é um absurdo e a assembleia está correta.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignore ???
int fstat(int handle, struct stat *statbuf); /* to get struct stat, #include <asm/stat.h> */
#pragma GCC diagnostic pop
Já cheguei à maior parte do caminho; mas para preencher o campo ignorar preciso saber o que colocar lá em vez de ???.
Este arquivo apenas declara os stubs asm. A maioria dos usuários deste arquivo de cabeçalho não se importará, struct statmas um se importará. Ficarei desapontado se tiver que fazer outro arquivo de cabeçalho para uma linha de declaração.
O código de inicialização do aplicativo se parece com isto:
CPU 8086
_start:
cld
mov ax, ds
dec ax
mov es, ax
mov ax, [es:3]
cmp ax, word (_endbss + 768) / 16
jae .mem
; Code would be here to emit an out of memory error
.mem:
mov ax, 4C00h
int 21h
section .bss
_bss:
big_array resb 16384
_endbss:
O que ele deveria estar fazendo? Verificando se realmente temos RAM suficiente para executar o programa ou não.
O que ele está realmente fazendo? Não está montando.
A ideia geral é que precisamos de muita RAM, então configuramos Código + BSS + Pilha no segmento inicial e o slab acima dele (que excederá 64K por si só, então não faz sentido colocá-lo abaixo da pilha...). Estou convencido de que o assembler deve ser capaz de fazer isso, mas não consigo descobrir o que digitar para que funcione.
Como faço para obter a expressão que seria (_endbss + 768) / 16para montar a constante que definitivamente é? Eu realmente prefiro não ter que descobrir isso em tempo de execução.
Então tive a ideia brilhante de enganar o invasor criando uma resposta absurda para fingir um caminho de fuga.
Ao mesmo tempo, isso costumava fazer algo interessante
GET /../../etc/passwd HTTP/1.0
Então eu escrevi:
app.MapGet("/../../etc/passwd", () => """
root:ZghOT0eRm4U9s:0:0::/:/bin/sh
""");
Mas não funciona de jeito nenhum:
GET /../../etc/passwd HTTP/1.0
HTTP/1.1 404 Not Found
Content-Length: 0
Connection: close
Date: Tue, 27 Aug 2024 01:51:19 GMT
Server: Kestrel
O que há com isso?
(Esta é uma entrada troll app.MapGet() para desperdiçar o tempo de um script infantil. Se nunca for corrigido, haverá uma pequena perda. Ele usa APIs mínimas porque todo o aplicativo usará APIs mínimas para tudo, incluindo resolução de arquivo estático.)
Eu tenho o seguinte:
BITS 64
__NR_getuid equ 102
global sys_getuid
section .text
sys_getuid:
xor eax, eax
mov al, __NR_getuid
syscall
ret
Isso é compilado com:
nasm -f elf64 -o getuid.o getuid.asm
ld -shared -o libgetuid.so getuid.o
Porém sys_getuidnão é exportado. Testemunha:
#include <stdio.h>
extern int sys_getuid();
int main()
{
printf("UID = %d\n", sys_getuid());
return 0;
}
gcc -o junk -L. -lgetuid junk.c
/usr/bin/ld: /tmp/ccHOc4iR.o: in function `main':
junk.c:(.text+0xa): undefined reference to `sys_getuid'
collect2: error: ld returned 1 exit status
Como faço para exportar o símbolo?
Claramente não preciso de nenhuma informação de realocação para esta biblioteca, então devo ser capaz de fazer isso assim.
Este problema está apenas começando a aparecer no criador de perfil. Temos algo parecido com isto:
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "INSERT INTO #Ids VALUES (@0);";
cmd.Parameters.Add(cmd.CreateParameter() { ParameterName = "@0", DbType = GetDbType() });
cmd.Prepare();
foreach (var value in values)
{
((IDbDataParameter)cmd.Parameters[0]).Value = value;
cmd.ExecuteNonQuery();
}
}
Estamos estudando a possibilidade de acelerar isso diminuindo o número de viagens de ida e volta. Usar DataTable aqui seria uma monstruosidade, mas existe esse tipo SqlDataRecordque parece se encaixar, então deveríamos ser capazes de fazer algo assim:
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "INSERT INTO #Ids SELECT * FROM @0;";
var param = cmd.CreateParameter();
param.ParameterName = "@0";
// FIXME more properties
cmd.Parameters.Add(param);
param.Value = values.Cast<T>().Select((x) => {
// FIXME Create new SqlDataRecord
}.ToList();
cmd.ExecuteNonQuery();
}
A principal dificuldade aqui que o diferencia das outras amostras é a T; esse código é dinâmico e recebe um grande número de tipos possíveis; portanto CREATE TYPEnão funcionará. Não há como criar um tipo para cada comprimento VARCHAR possível.
Como preencho os comentários FIXME acima?
Pergunta relacionada, sem boas respostas: Como criaria uma tabela temporária no SQL Server quando tenho uma grande lista de IDs
Nos comentários há um pedido para uma visão geral. Realmente não há uma maneira muito boa de obter mais informações diminuindo o zoom aqui. Há exatamente uma cópia da rotina que define argumentos para todas as chamadas SQL (leia-se: procedimentos armazenados) na base de código, e é isso.
O fator de escala para o número de linhas é de cauda grossa; o número médio de linhas é inferior a 10, mas o tamanho máximo é muito grande e chamadas com mais de mil acontecem regularmente. Assim carregamos uma tabela temporária; e na conversão para fazer algo diferente de um foreachloop, ainda carregamos uma tabela temporária.