Midliner: Avoids Trusted Third Party

26 Oct 2025

      I found there was a leak from 6 years ago, it was likely that Peer-to-Peer communication messages would have been much slower or never delivered, the solution you can currently do is to require something like Cleopatra then put some important files or directories into a backup such as a D folder or the highest sized Flash drive, Don't connect communication tools or peers with the internet too often.

Here is Pseudocode Hashing or Cryptography Hashing that you can implement, this avoids Trusted third parties in communication between computers, with midliners will make the wordlist neater and structured.

Don't use Windows! and this is the Cryptography I designed, you can compile and run in Multi Languages.

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;

public class SAI288 {
    private static final int ROUNDS = 64;
    private static final int STATE_SIZE = 9;
    private static final int BLOCK_SIZE = 72;
    private static final int OUTPUT_SIZE = 36;

    private static final int[] IV = {
        0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
        0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, 0x452821E6
    };

    private int[] state = new int[STATE_SIZE];
    private byte[] buffer = new byte[BLOCK_SIZE];
    private byte[] midliner = new byte[BLOCK_SIZE];
    private int bufferPos = 0;
    private long totalBytes = 0;

    public SAI288() {
        reset();
    }

    public void reset() {
        System.arraycopy(IV, 0, state, 0, STATE_SIZE);
        Arrays.fill(buffer, (byte) 0);
        Arrays.fill(midliner, (byte) 0);
        bufferPos = 0;
        totalBytes = 0;
    }

    private void processMidliner(byte[] data) {
        for (int i = 0; i < data.length && i < BLOCK_SIZE; i++) {
            midliner[i] ^= data[i];
        }
    }

    public void update(byte[] data) {
        update(data, 0, data.length);
    }

    public void update(byte[] data, int offset, int length) {
        processMidliner(Arrays.copyOfRange(data, offset, offset + Math.min(length, BLOCK_SIZE)));
        totalBytes += length;
        int remaining = length;
        int dataPos = offset;

        while (remaining > 0) {
            int toCopy = Math.min(remaining, BLOCK_SIZE - bufferPos);
            System.arraycopy(data, dataPos, buffer, bufferPos, toCopy);
            bufferPos += toCopy;
            dataPos += toCopy;
            remaining -= toCopy;

            if (bufferPos == BLOCK_SIZE) {
                processBlock(buffer);
                bufferPos = 0;
            }
        }
    }

    private void processBlock(byte[] block) {
        int[] m = new int[18];
        ByteBuffer bb = ByteBuffer.wrap(block).order(ByteOrder.LITTLE_ENDIAN);

        for (int i = 0; i < 18 && bb.hasRemaining(); i++) {
            m[i] = bb.remaining() >= 4 ? bb.getInt() : 0;
        }

        for (int round = 0; round < ROUNDS; round++) {
            for (int i = 0; i < STATE_SIZE; i++) {
                state[i] ^= m[i % 18];
                state[i] = Integer.rotateLeft(state[i], (round + i) % 32);
                if (i > 0) {
                    state[i] += state[i - 1];
                }
            }

            for (int i = 0; i < 18; i++) {
                m[i] = Integer.rotateRight(m[i] ^ state[i % STATE_SIZE], 7);
            }
        }
    }

    public byte[] digest() {
        byte[] padded = new byte[BLOCK_SIZE];
        System.arraycopy(buffer, 0, padded, 0, bufferPos);
        padded[bufferPos] = (byte) 0x80;

        ByteBuffer bb = ByteBuffer.wrap(padded, BLOCK_SIZE - 8, 8).order(ByteOrder.LITTLE_ENDIAN);
        bb.putLong(totalBytes * 8);

        processBlock(padded);
        processBlock(midliner);

        ByteBuffer output = ByteBuffer.allocate(OUTPUT_SIZE).order(ByteOrder.LITTLE_ENDIAN);
        for (int i = 0; i < STATE_SIZE; i++) {
            output.putInt(state[i]);
        }

        byte[] result = new byte[OUTPUT_SIZE];
        output.flip();
        output.get(result);
        reset();
        return result;
    }

    public static byte[] hash(byte[] data) {
        SAI288 hasher = new SAI288();
        hasher.update(data);
        return hasher.digest();
    }

    public static native byte[] hashNative(byte[] data);
}

The main languages are Java, the other Multi Languages are C++ and Rust and Swift

After the data or a lot of data in STMIK IKMI CIREBON has been hashed, do Kleopatra or get PGP from there, you can install config from the Open Quantum Safe library and with liboqs, it will build C Objects and find a lot of Digital Signature Cryptography but avoid kube Crystals Kyber, Summary in Indonesian: Data anda telah bocor, komunikasi antar peer telah dikontrol penuh oleh Pihak Ketiga, yang kami tawarkan adalah paket yang dapat tersampaikan dari Node satu ke Node lainnya tanpa memerlukan akses N-Bit, ini tidak mencampuri dan tidak merusak database statistik atau data identitas, perlu verifikasi lebih lanjut sebelum anda percayai ini, jangan simpan sepenuhnya dalam Komputer, karena setiap Device yang anda beli meskipun itu adalah barang yang tersegel, Litografi baik IOS dan Android memiliki pemicu kontrol dari Node jahat.

I Gave all so concretly from what i did.

-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: User ID:	Alshen Feshiru <alshenfeshiru@zohomail.com>
Comment: Valid from:	06/10/2025 09:35
Comment: Valid until:	02/04/2033 12:00
Comment: Type:	448-bit EdDSA (secret key available)
Comment: Usage:	Signing, Encryption, Certifying User IDs
Comment: Fingerprint:	5871D671C35C12147308395A464505DE1047DA134C01C8EBF8D18D6B8CBD7763

mEkFaOMrBhYAAAA/AytlcQHHbHV7SgCdlZnHrIjtxAfcYYzs9R5GGNK46dlgzFzR
B+1X8BPoMimXLemj9yoBK+lfLO7OaTZ9klqAtCtBbHNoZW4gRmVzaGlydSA8YWxz
aGVuZmVzaGlydUB6b2hvbWFpbC5jb20+iM0FExYKAE0iIQVYcdZxw1wSFHMIOVpG
RQXeEEfaE0wByOv40Y1rjL13YwUCaOMrBgIbAwUJDhXYSgULCQgHAgIiAgYVCgkI
CwIEFgIDAQIeBwIXgAAApU0Bx3DEN60mahYzDrGcFnvmZ/5UaBBQTnLoSfPwG8Hz
fYt/pLE+S/yMOrbDdUrg6LG0t33bh7Pu4BxjAAHGIAca1udLBqQZ6mYwpBI6Z2S0
XVIx+glBORH6ynYgZGBZOTBarTts7UctN7D0pbBE+J4Y7w9ooDEAuEwFaOMrBhIA
AABCAytlbwG/civ41G/UgMeMBiRTScXvU83nUgSPz4fma7iCz5ZVfUUP9wBuxVxd
n7gODEf7mnjE8Vt8XHgOZ6kDAQoJiLIFGBYKADIiIQVYcdZxw1wSFHMIOVpGRQXe
EEfaE0wByOv40Y1rjL13YwUCaOMrBgIbDAUJDhXYSgAAzGAByPZFSr2g/J57qB4r
3ISgR4+mn83R9+R2TZL7s1qnDsqjw+t6B/b28dwlVxSXgXJtAcbW2hDlzORJAAHG
O8MVhPLaPra69/XvhuhZW9vOw4YXydY9aW+63KiNA6iIeZz9HczEOvT6vdWjIj8f
aQN2OLDD/yUA
=Gs+D
-----END PGP PUBLIC KEY BLOCK-----