Fonte: mempool.space

Esta proeza está permanentemente registrada no bloco 836361

inclusão de arquivos dentro do bloco

Cada bloco comporta aproximadamente 4000 transações individuais de tamanho reduzido...

Cerca de um ano antes, o bloco 774628 teve a inclusão de uma imagem JPG (arquivo com , tornando-a uma data cujo marco está permanente dentro do maior bloco do bitcoin. A imagem original pode ser visualizada a seguir.

Fonte: aqui

Para os leitores céticos fica a sugestão baixar a transação completa e fazer a extração dos cerca de 4 MB que compõem o arquivo JPEG.

Mais detalhes, vejas as matérias que veicularam na época

• https://cointelegraph.com/news/bitcoin-block-art-marathon (26.03.2024)
• https://blockworks.co/news/inside-bitcoin-biggest-block (02.02.2023)
• .

Qual deverá ser a próxima proeza?

---------------------------------- K ----------------------------------   --- H ---
428A2F98 71374491 B5C0FBCF E9B5DBA5 3956C25B 59F111F1 923F82A4 AB1C5ED5    6A09E667
D807AA98 12835B01 243185BE 550C7DC3 72BE5D74 80DEB1FE 9BDC06A7 C19BF174    BB67AE85
E49B69C1 EFBE4786 0FC19DC6 240CA1CC 2DE92C6F 4A7484AA 5CB0A9DC 76F988DA    3C6EF372
983E5152 A831C66D B00327C8 BF597FC7 C6E00BF3 D5A79147 06CA6351 14292967    A54FF53A
27B70A85 2E1B2138 4D2C6DFC 53380D13 650A7354 766A0ABB 81C2C92E 92722C85    510E527F
A2BFE8A1 A81A664B C24B8B70 C76C51A3 D192E819 D6990624 F40E3585 106AA070    9B05688C
19A4C116 1E376C08 2748774C 34B0BCB5 391C0CB3 4ED8AA4A 5B9CCA4F 682E6FF3    1F83D9AB
748F82EE 78A5636F 84C87814 8CC70208 90BEFFFA A4506CEB BEF9A3F7 C67178F2    5BE0CD19

echo "" | awk --sandbox '{
    j = 0;  # Inicializacao do indice para constantes H
    
    # Numeros primos de 2 a 317
    primes = "  2,   3,   5,   7,  11,  13,  17,  19,  23,  29,  31,  37,  41,"\
             " 43,  47,  53,  59,  61,  67,  71,  73,  79,  83,  89,  97, 101,"\
             "103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,"\
             "173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239,"\
             "241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313 ";
    
    n = split(primes, p, ",");  # Transcreve para vetor os números primos dados
    # Imprime um cabecalho
    printf("---------------------------------- K ");
    printf("----------------------------------   --- H ---\n");
    
    for(i = 1; i = 64; i++) {
        # Calcula e imprime as constantes K( 1) até K(64)
        c = p[i]^(1/3); k = int(2^32*(c-int(c))); printf("%08X ", k);
        if(!(i%8)) {
            j++; 
            # Calcula e imprime as constantes H(1) até H(8)
            b = p[j]^(1/2); h = int(2^32*(b - int(b))); printf("   %08X\n", h);
         };
    }
}'

Mas, qual é a origem, o significado e o motivo destas constantes?

Ao utilizar as partes fracionárias das raízes cúbicas dos 64 primeiros números primos (NIST.FIPS.180-4, pag. 11) para geração das constantes K e utilizar as partes fracionárias das raízes quadradas dos 8 primeiros números primos (NIST.FIPS.180-4, pag. 15) para geração das constantes H, cria-se, desta forma, um conjunto de constantes que tornam a função hash resistente a ataques, garantindo um comportamento complexo e menos previsível. Para obter as constantes, aquelas partes fracionárias são então multiplicadas por 2^32, os resultados truncados para inteiros e então impressos na base numérica hexadecimal. Tais valores são então facilmente obtidos de maneira determinística e, para que haja consistência das saídas de hash em diferentes implementações do algoritmo, tais valores devem ser mantidos fixos. Essas constantes mágicas usadas no algoritmo de hash SHA-256 proporcionam uma não-linearidade para a função hash.

Aplicações do SHA-256

SHA-256 é amplamente utilizada como função criptográfica de hash, produzindo uma saída de 256 bits independente do número de bytes fornecidos na sua entrada (um simples caractere ou arquivos inteiros). Outra aplicação relevante é no algoritmo de mineração de um dos ativos digitais mais conhecidos, onde se aplica a função duas vezes, ou seja, sha256(sha256(conteúdo)) e por isso às vezes é denominada sha256d.

# Uses      :  python 2
# Dependency:  hashlib
import hashlib

# Hash pairs of items recursively until a single value is obtained
def merkle(hashList):
    if len(hashList) == 1:
        return hashList[0]
    newHashList = []
    # Process pairs. For odd length, the last is skipped
    for i in range(0, len(hashList)-1, 2):
        newHashList.append(hash2(hashList[i], hashList[i+1]))
    if len(hashList) % 2 == 1: # odd, hash last item twice
        newHashList.append(hash2(hashList[-1], hashList[-1]))
    return merkle(newHashList)

def hash2(a, b):
    # Reverse inputs before and after hashing
    # due to big-endian / little-endian nonsense
    a1 = a.decode('hex')[::-1]
    b1 = b.decode('hex')[::-1]
    h = hashlib.sha256(hashlib.sha256(a1+b1).digest()).digest()
    return h[::-1].encode('hex')

# https://blockexplorer.com/rawblock/0000000000000000e067a478024addfecdc93628978aa52d91fabd4292982a50  (outdated)
# wget -qO- https://mempool.space/api/block/00000000000ace2adaabf1baf9dc0ec54434db11e9fd63c1819d8d77df40afda/txids
# expected Merkle Root
# wget -qO- https://mempool.space/api/block/75000
# ed385c2dbc69aa24965909c7d9d11bbd99faa085cb4ec17865d9b557ffb3a68a
#
txHashes = ["5277cf3790381c2cc2b071038d8c35b3b601207c92f8aec15978a5f01ecf8319",
"182c2ed191a35ea496ce84c42d8beee6f9d82b9f063de2e45a54692bb043696a",
"707e86e5e2356cb53a2edf0be391d56cfc998bcfa05a13a5772ef474c5eba105",
"711e15a9a819de4d1269d71de9744dedf9b6c32bba36bb0196f003f6507d4bb4",
"8c1e409484e30c205698647753cca07d826c34756773bd0432202487f28e2d54",
"abfaf8e7ad6241ca5161e517baade1275cf6333d0d118d221f894813bacb4f78"]

print merkle(txHashes)

Fontes

• https://www.youtube.com/watch?v=gUwXCt1qkBU
• https://www.righto.com/2014/02/bitcoin-mining-hard-way-algorithms.html

#include <stdio.h>
#include <math.h>

// Prototypes
void mxinverse(double* matrix, int n);
void mxmult(double* matrixA, double* matrixB, double* matrixC,
            int mA, int nA, int mB, int nB);
void mxadd(double* matrixA, double* matrixB, double* matrixC,
            int mA, int nA, int mB, int nB, double alpha, double beta);


// ToDo: Improve this function returning a status value
void mxinverse(double* matrix, int n) {
    int i, j, k;
    double sum;

    for (i = 0; i < n; i++) {
        for (j = i; j < n; j++) {
            sum = matrix[i * n + j];
            for (k = i - 1; k >= 0; k--) {
                sum -= matrix[i * n + k] * matrix[j * n + k];
            }
            if (i == j) {
                // What happen when sum < 0.0?
                matrix[i * n + i] = sqrt(sum);
            } else {
                // What happen when matrix[i * n + i] == 0.0?
                // ToDo: return a status value
                matrix[j * n + i] = sum / matrix[i * n + i];
            }
        }
    }

    for (i = 0; i < n; i++) {
        for (j = i; j < n; j++) {
            sum = (i == j) ? 1.0 : 0.0;
            for (k = j - 1; k >= i; k--) {
                sum -= matrix[j * n + k] * matrix[j * n + k];
            }
            // What happen when matrix[i * n + i] == 0.0?
            // ToDo: return a status value
            matrix[j * n + i] = matrix[j * n + i] / matrix[i * n + i];
            matrix[i * n + j] = sum / matrix[i * n + i];
        }
    }

    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++) {
            for (k = i + 1; k < j; k++) {
                matrix[j * n + i] -= matrix[j * n + k] * matrix[k * n + i];
            }
                // What happen when matrix[i * n + i] == 0.0?
                // ToDo: return a status value
                matrix[j * n + i] /= matrix[j * n + j];
        }
    }
}


// C[i,j] = alpha * ( A[i,j] * B[i,j] ) + beta * C[i,j] // C = A  * B
// C[i,j] = alpha * ( A[j,i] * B[i,j] ) + beta * C[i,j] // C = A' * B
// C[i,j] = alpha * ( A[j,i] * B[j,i] ) + beta * C[i,j] // C = A' * B'
// C[i,j] = alpha * ( A[i,j] * B[j,i] ) + beta * C[i,j] // C = A  * B'
// 
void mxmult(double* matrixA, double* matrixB, double* matrixC,
            int mA, int nA, int mB, int nB, double alpha, double beta) {               
  // ToDo: Implement the algorithm
}


// C[i,j] = alpha * A[i,j] + beta * B[i,j] + gamma
//
// Changing alpha and beta, it is possible to implement mxsub
void mxadd(double* matrixA, double* matrixB,
           int mA, int nA, int mB, int nB,
           double alpha, double beta, double gamma) {
    
}

<svg
  xmlns="http://www.w3.org/2000/svg"
  width="142px"
  height="23px"
  fill="none"
>
<foreignObject width="142px" height="23px">
<div xmlns="http://www.w3.org/1999/xhtml">
<style>
.pill{
    display: flex;
    background-color: transparent;
    width: max-content;
    font-family: 'Open Sans', sans-serif;
    border-radius: 4px;
}
.pillLabel{
    display: flex;
    width: max-content;
    padding: 4px;
    padding-left: 8px;
    padding-right: 8px;
    border-top-left-radius: 4px;
    border-bottom-left-radius: 4px;
    font-size: 12px;
    color: rgb(254 215 170);
    background-color: rgb(136 19 55);
}
.pillIcon{
  margin-right: 4px;
  width: 14px;
  height: 14px;
}
.pillCount{
    color: rgb(136 19 55);
    background-color: rgb(254 215 170);
    width: max-content;
    border-top-right-radius: 4px;
    border-bottom-right-radius: 4px;
    padding: 4px;
    padding-left: 8px;
    padding-right: 8px;
    letter-spacing: 1px;
    font-size: 12px;
}

@keyframes heartbeat {
  0% {
      transform: scale(1);
  }
  25% {
      transform: scale(1.1);
  }
  40% {
      transform: scale(1);
  }
  60% {
      transform: scale(1.1);
  }
  100% {
      transform: scale(1);
  }
}

.heartbeat {
  display: inline-block;
  animation: heartbeat 1.5s infinite;
  transform-origin: center;
  image-rendering: -webkit-optimize-contrast;
  image-rendering: crisp-edges;
  backface-visibility: hidden;
  will-change: transform;
}

</style>
<div class="pill">
<span class="pillLabel">
<svg xmlns="http://www.w3.org/2000/svg" class="pillIcon heartbeat" fill="none" viewBox="0 0 24 24" stroke="currentColor">
  <path name="bar" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z" />
</svg>
Profile Views</span>
<span class="pillCount" > 42 </span>
</div>
</div>
</foreignObject>
</svg>

user_agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36"

wget --verbose --mirror --no-parent --continue --page-requisites \
     --adjust-extension --convert-links --no-clobber --timestamping \
     --server-response --limit-rate=10k --wait=10 --random-wait \
     --no-cache --user-agent="${user_agent}" --no-check-certificate <website.address>

Mas existe alguma maneira de se defender dessa prática quando a mesma se torna nociva para o servidor, aumentando a carga para um propósito realizado por não-humanos? Contratar um proxy que implemente desafios (CAPTCHA) pode ser uma solução.

Mas será que é possível criar uma solução independente de proxy? E se a página web fosse dinâmica, ou seja, montada em tempo de carga usando somente javascript e uma conexão via websocket seguro com o servidor (nos códigos seguintes é ws em vez de wss)? Por meio do websocket o Javascript obtém o conteúdo a ser montado na página no lado do cliente. Tais recursos dinâmicos ainda não são interpretados pelos crawlers burros.

Esta ideia é possível e o fluxo básico para realizar isso envolve os seguintes passos:

1. Conexão WebSocket com o Servidor

A primeira etapa é estabelecer uma conexão WebSocket com o servidor. O WebSocket permite uma comunicação bidirecional em tempo real, ideal para atualizar e carregar dados dinâmicos.

const socket = new WebSocket('ws://servidor.com:porta');

// Quando a conexão é aberta
socket.onopen = function(event) {
    console.log("Conectado ao servidor via WebSocket.");
    socket.send("Solicitando dados para a página");
};

// Quando uma mensagem é recebida do servidor
socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    montarPagina(data);
};

// Tratamento de erros
socket.onerror = function(error) {
    console.log("Erro na conexão WebSocket:", error);
};

// Quando a conexão é fechada
socket.onclose = function(event) {
    console.log("Conexão WebSocket fechada.");
};

2. Recebendo o Conteúdo

Quando o servidor envia os dados, eles podem estar no formato JSON (ou outro formato estruturado). Ao receber os dados, o JavaScript no lado do cliente pode processar e montar o conteúdo da página dinamicamente.

3. Construção da Página no Lado do Cliente

Uma vez que os dados são recebidos, você pode manipulá-los e gerar o conteúdo da página dinamicamente usando DOM (Document Object Model) ou técnicas como innerHTML.

Exemplo simples de código:

function montarPagina(data) {
    const body = document.body;

    // Criar elementos de acordo com os dados recebidos
    const titulo = document.createElement('h1');
    titulo.textContent = data.titulo;

    const conteudo = document.createElement('p');
    conteudo.textContent = data.conteudo;

    // Adicionar os elementos na página
    body.appendChild(titulo);
    body.appendChild(conteudo);
}

4. Servidor WebSocket

Do lado do servidor, você precisa configurar um serviço WebSocket que envie os dados requisitados ao cliente. O servidor deve manter a conexão aberta enquanto for necessário para enviar novos dados dinamicamente ou quando solicitado.

Um exemplo básico de servidor WebSocket em Node.js:

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
    console.log('Cliente conectado');

    ws.on('message', (message) => {
        console.log('Mensagem recebida: %s', message);
        const dadosPagina = {
            titulo: "Bem-vindo à minha página!",
            conteudo: "Este conteúdo foi carregado dinamicamente via WebSocket."
        };
        ws.send(JSON.stringify(dadosPagina));
    });

    ws.on('close', () => {
        console.log('Cliente desconectado');
    });
});

Benefícios:

• Atualização em tempo real: O WebSocket permite que o servidor envie atualizações em tempo real ao cliente sem a necessidade de recarregar a página.
• Eficiência: Reduz a sobrecarga de requisições HTTP/HTTPS repetidas, já que a conexão WebSocket permanece aberta.
• Experiência do usuário: O conteúdo pode ser carregado e atualizado dinamicamente conforme necessário.

Desafios:

• Gestão de estados e reconexão: É necessário garantir que o cliente possa lidar com a desconexão e reconectar caso a comunicação falhe.
• Segurança: A comunicação via WebSocket deve ser protegida para evitar ataques como Man-in-the-Middle (usando WSS em vez de WS).

Essa abordagem é útil para aplicações em tempo real ou dinâmicas, como sistemas de votação, chat ou dashboards de monitoramento em tempo real. Por ser um conteúdo dinâmico, os crawlers burros não conseguirão baixar o conteúdo, mas apenas a página principal contendo o mínimo, básico para que o navegador (Chrome, Firefox, Opera etc.) consiga iniciar a carga e montagem da página dinamicamente.

[Keywords: crawler, defeat, dynamic page, javascript, websocket] // for [index|filter]ing purposes